text:
\section{Introduction}
Artificial consciousness \cite{chella2013artificial} is an emerging multidisciplinary area that propose computer science implementations to models coming from neuroscience \cite{crick1998consciousness} and discussed in philosophy of mind \cite{chalmers2002philosophy}. With the recent advancement of technology and machine learning methods \cite{murphy2012machine}, the field can propose new implementations of cognitive architectures using the latest proposed methodologies and techniques.

Not only has the artificial consciousness advances but also discussions coming from philosophy of mind regarding consciousness \cite{kim2018philosophy}. As artificial intelligence \cite{russell2002artificial} and neuroscience advance, new questions are being discussed by philosophers over these improvements. Nevertheless, at least as far as we know, this does not happen the other way round and computer science does rarely use philosophy of mind and neuroscience ideas to keep developing its methods. For example, deep learning methods do not worry about the hypothesis that if living beings are the result of evolution and are conscious, then consciousness must give an evolutionary advantage over mere unconscious proccesing of information such as the one happening in deep learning.
The motivation of the present work is to explore the utility of artificial consciousness models that in the future could be used, for example, to improve the quality of autonomous robotic systems (e.g., better performance efficiency). We do not intend to deliver a state-of-the-art deep learning method but only to start exploring how computer science models may imitate the flow of information that living beings do to see whether that processing of information produces a reasonable behaviour. The obtained results from the experiments of the implementation of our approach may also be useful to provide quantitative evidence that help to justify the need of consciousness in biological beings. We also discuss how our proposed cognitive architecture relates with the main philosophy of mind ideas regarding consciousness in an attempt to being a bridge between the two disciplines and motivate the study and implementation of philosophy of the mind ideas in computer science.

Previous work has been done regarding artificial consciousness \cite{reggia2013rise,soto2017artificial}. The literature contains the implementation of robots simulating correlated behaviours of beings exhibiting consciousness \cite{seth2009explanatory}. Other works include artificial consciousness cognitive software architectures such as a neuronal model of a global workspace for cognitive tasks \cite{dehaene1998neuronal}. The consciousness prior model \cite{bengio2017consciousness} is an alternative to this approach based in sparse factor graphs that have some similar elements to our proposed architecture. It will be further discussed in the philosophy of mind section of this paper. Machine learning \cite{alpaydin2020introduction} and deep reinforcement learning \cite{li2017deep} techniques are able to manage a big quantity of information and could be incorporated in both our proposed architecture and in other ones. Artificial consciousness models are classified into 4 levels depending on the characteristics of the implementation. Cognitive architectures involving different modules that exhibit behaviour correlated with consciousness are classified as level 3 systems and system that can arise potential phenomenal experiences would be considered level 4 machine consciousness system \cite{gamez2018human}. Our proposed approach is a level 3 cognitive architecture system as, from our point of view, we do not have the tools to determine whether level 4 systems could be implemented in practice. Although, this will be discussed in the philosophy of mind section of this work.

This manuscript is organized as follows: We have already discussed related work and an introduction to artificial consciousness. We will now propose the different involved modules and models of the cognitive architecture for a potentially conscious agent and possible enhancements of them. We then present the cognitive architecture that consist on the previously described modules. Once that the model has been explained, we discuss the connections that our proposed approach have with philosophy of the mind theories and how our model fits some of these theories, like the functionalism theory. We continue with an exhaustive set of experiments where we show how an agent implementing our architecture exhibits an autonomous behaviour. Finally, we conclude the paper with some conclusions and future work proposals.

\section{Modules of the cognitive architecture of the robot}

Before describing the modules of the robot, we need to define the environment where it is going to be placed. The environment is a finite \(2D\) space represented as a grid $\mathbf{G}$ of dimension \(N \times N\) cells. Each cell contains observable physical magnitudes. In a real world, for example, these magnitudes could correspond to temperature, humidity, light, noise, presence of obstacles, etc. We use abstract magnitudes identified by \(m_1, .., m_n\). The value of each physical magnitude is represented by a normalized real number in the interval \([-a, +a]\)(for example, \( a=10\)).

The robot is able to perceive magnitudes using sensors. When the robot is located in a particular cell, it perceives information of each adjacent cell from every direction \((up, down, left, right)\). If, for example, there are five magnitudes, the robot perceives a total of 20 values (4 directions multiplied by 5 observed magnitudes). The robot is able to move in the environment by doing one of four basic motion actions: \(up, down, left, right\) in a particular instant. We represent with $\mathcal{X}$ the set of possible actions that the robot may take.

Having described the environment and how the robot moves, we describe the modules of our proposed implementation of a global workspace model architecture. These modules are an attention process that filters information that is not necessary for the robot to make a conscious decision, the long and short term memories, the sensors that the robot uses to detect information from the environment, the evaluation system, the motor system, the degree of happiness that the robot possesses and the most important process, the global workspace process.

We define that a robot has a set of feelings. In this model, we only consider one type of feeling that corresponds to the happiness degree. It is represented as $h \in \mathbb{R} : h \in [0,10]$ and can be initialized, for example in $h=5$ in such a way that higher values are good and lower are bad. If happiness degree decreases too much passing a threshold $\tau$, for example $\tau=2$, the robot deactivates, simulating death. As explained below, in this setting, the objective of the robot is to optimize its happiness degree $h$ w.r.t a single step in the grid $\mathbf{G}$. In other words, the decision $x^*$ that the robot takes follows $x^* = \arg \max_{x \in \mathcal{X}} f(x,t|h,\mathbf{\Theta}, \mathbf{p})$, where $\mathcal{X}$ is the set of possible actions that the robot may take in time $t$ conditioned to its happiness degree $h$ and in multiple flows of information $\mathbf{\Theta}$, which are the subconscious importance that the robot gives to every possible action $x$, and the short and long term memory about the actions that the robot is aware of. Lastly, $\mathbf{P}$ is a matrix of preferences that describes, for every sensor $s_k$ of the grid $\mathbf{G}$, the values of the sensor that make the objective $h$ of the robot change. For the shake of simplicity, in this implementation we have used a single objective $f(\cdot)$ (with the degree of happiness $h$) but in a more realistic situation this should be represented by a set of objectives $\mathbf{f}$. The problem that appears is that, for any time $t$, we can only evaluate $f$ for a single action $x$. As it is going to be explained later, this function $f$ is computed by the evaluative system and $f$ is estimated for $\mathcal{X}$ by the attentional system $a(\mathcal{X}|\mathbf{\theta}) \approx f$ where $\mathbf{\theta}$ is the set of weights of the attentional system and also estimated for the most relevant actions according to the attentional system by the global workspace model $g(a(\mathcal{X}|\mathbf{\theta})|\mathbf{\Theta}) \approx f$, employing all the information in $\mathbf{\Theta}$, that includes weights for the most relevant actions decided by the attentional system (subconscious decision) $a(\mathcal{X}|\mathbf{\theta})$, the short $\mathbf{s}(t)$ and long term memory $\mathbf{l}(t)$ and the current state of the objective that we are maximizing $h(t)$. The robot hence want to maximize, for every step $t$, the feeling $h$, emulating happiness, through $f(\cdot)$ that can only be executed once for every $t$ by the evaluative system. In order to make a proper decision to maximize $h(t)$, it maximizes $a(\cdot)$ and $g(\cdot)$ which are approximations to $f(\cdot)$ based in the cognitive information learned from the environment by the robot.

Each robot has its preferences $\mathbf{P}$ that represent how good a certain value given by a sensor $s_k$ observed in the environment grid $\mathbf{G}$ is for the robot. Each position $g_{ij}$ of the grid contains magnitudes observed by sensors. Preferences are functions of the magnitudes that affect how the situation is evaluated by the robot. The evaluative system conditions the evaluation of a position and magnitude $(g_{ij}, p(m_k))$ to the preferences of that sensor of the robot $\mathbf{p}_k$. Each robot can have different preferences. More details about the parametric expressions of these functions are given in the experiments section.

A belief is a conscious conclusion inferred by the robot that can be stored in the memory as experience to be used later as a tuple $(r|m_l,s_k,t)$, that is, a movement $m_l$ (up, down, left, right) exploring a sensor $s_k$ at time $t$ that has been evaluated with reward $r$. This conclusion is given by the evaluative system as a result of evaluating $f(x^*,t|h,\mathbf{\Theta}, \mathbf{p})$.  The information that we need to store and that conditions all the weights of the system is basically how good or bad is moving to a certain direction $m_l$. These beliefs tuples, $B$, are going to be stored in the long term memory $\mathbf{l}$ if a threshold $\beta_l$ is reached when we evaluate an action by the evaluative system $|f(m_l,s_k)| > \beta_l$ or in the short term memory with another threshold. Beliefs are ranked in the memory according to their relevance $f(\cdot)$. To simulate forgetting beliefs, we use the parameter \(l\) that represents the maximum number of beliefs in the memory. In the long term memory, beliefs that are less relevant are deleted first.  When beliefs have the same degree of relevance, oldest beliefs are deleted first. In the short term memory, new beliefs substitute older beliefs independently of their degree of relevance.

The reactive attention expresses how the robot pays attention \cite{american1998attention} to observations of sensors $s_k$ performed on each position of the grid $g_{ij}$. The attentional system represents the subconscious decision about the importance of all the inputs given by the perceptual system of the robot. The subconscious system of the robot pays attention to all the information of every position that the robot perform in time $t+1$ and of all the sensors that the robot can evaluate in time $t+1$. That is $m$ possible movements multiplied by $k$ sensors generating $mk$ possible actions that the robot can perform at time $t$. The consciousness bottleneck limits the amount of information that a human being can pay attention to in a certain time $t$, but a human brain is processing all the information given by the human senses, that is, the perceptual system of the robot. This is done in the subconscious mind, here the attentional system of the robot. This attentional system then is going to select $A$ possible actions from the available $mk$, for example $A=2$ that is going to transfer to the global workspace model, which is representing the awareness experience of the human being. In order to select which are the most important actions $x$, every possible $mk$ action is represented by a weight $w_{i} \in [0,1] : \sum_{i=0}^{mk} w_{i} = 1$, that is, a multinomial distribution of weights that is initialized randomly or uniformly. The decision about which is the most important action is done probabilistically according to that weights and to the inputs given by the perceptual system $x_{mk}$. The attentional system does not have access to the evaluation system because the action has not been performed and the robot has not taken a conscious decision about the next step.

We sample $A$ indexes from that multinomial distribution and that indexes determine the actions that are going to be transferred to the global workspace $a \sim M(\mathbf{w})$. These weights are also going to be conditioned by the happiness degree of the robot to represent the survival instinct of consciousness. If the robot has a value for $h$ far from the death threshold, then, exploration of new sensors and movements is encouraged and the selection is done probabilistically as described.  However, if the robot feeling value is close to death, $h < \tau + \epsilon$ then the selection will be done with a ranking of the weights. The idea is to exploit the actions that have been good in the past.

Another mechanism that needs to be described of the attentional system is how are the weights $\mathbf{w}$ adapted from the evaluations done by the evaluation system $f(\cdot)$. These adaptations $\delta$ of the weights are going to be determined by the quality of the evaluation $f(\cdot)$ and the feeling objective value $h$, that is $\delta = e(f(\cdot),h)$. For $e(\cdot)$, we propose the following function, if the robot is not close to death $h \geq \tau + \epsilon$, then, we propose a learning rate sampled from a Gaussian distribution $r \sim N(0.05,0.001)$. If the evaluation done by the evaluative system $f$ has lower value than the short and long term memory thresholds and is positive $f(\cdot)>0$, the selected weight is incremented by $w_* = w_* + r$ and the rest of the weights are normalized $\mathbf{w}_n = \mathbf{w}_n - \frac{r}{mk-1}$ where $\mathbf{w}_n$ does not contain $w_*$. If it is negative $f(\cdot)<0$, the selected weight is decremented by $w_* = w_* - r$ and the rest of the weights are normalized $\mathbf{w}_n = \mathbf{w}_n + \frac{r}{mk-1}$ where $\mathbf{w}_n$ does not contain $w_*$.

If the evaluation done by the evaluative system has involved storing a belief in the short term memory $|f(\cdot)|>\beta_s$, then the weights are varied with a higher learning rate, for example: $r \sim N(0.1,0.001)$. If the evaluation is extreme, involving the long term memory, the learning rate is also higher, for example, $r \sim N(0.2,0.001)$.
Lastly, a special update process occurs when the robot is close to death, modifying drastically the weights in order to not continuing a bad behaviour or encouraging a good behaviour. In this scenario, the weights are modified by an extreme learning weight which is $min(1,N(1-(h-\tau),0.001))$.

The selected tuples $(m_i,s_k)$ fed to the global workspace are weighted for this system by a quantity $w_a \in [0,1] : \sum_{a=0}^{A} w_a = 1$ proportional to the sum of the weights of the selected tuples. More formally, the computation that needs to be done is: $w_a = \frac{w_a}{\sum_{a=0}^{A} w_a}$.

The goal of the robot is to move in the environment in order to optimize its feelings. In our case, it corresponds to maximize the degree of happiness $h$ as a single objective $f$. In a more realistic scenario, the robot would use a set of feelings $\mathbf{f}$ which correspond to a multi-objective optimization.

At every time step $t$, the robot updates the happiness by the evaluation of a grid position and a sensor. The current state of happiness $h(t)$ is updated by the reward obtained by the evaluation system $r$ as $h(t+1) = h(t) + r$. In addition, at every time step $t$, the robot loses a fixed quantity of happiness, for example $c \sim N(0.01,0.001)$. The complete operation over the objective at every time $t$ is $h(t+1) = h(t) + r - c$. To avoid death, the robot must ensure that its happiness is above a configurable threshold $\tau$. That is the reason why, in order to survive, the robot must be always moving.

The perceptual system gets information of the grid $g_{ij}$ and the sensors $s_k$ in the form of observations of physical magnitudes given by the sensors of the robot and fed to the attentional system (subconscious mind) and to the evaluation system.

The global workspace makes a conscious decision about the action that is going to be performed at time $t$ with respect to the $A$ tuples $(m_i,s_k)$ given by the attentional system based on the importance given to those tuples by the attention system $a(\mathbf{x}|\mathbf{w})$, the short term memory $s(\mathcal{B}_s)$, where $\mathcal{B}_s$ is the set of short term beliefs, the long term memory $l(\mathcal{B}_l)$ and the degree of happiness $h$. The phenomenal experience (or subjective experience) is the following decision problem: which action to take \((up, down, left, right)\) based on the \(a\) tuples about observed physical magnitudes, or sensors $s_k$ and directions $m_i$ served by the attention module. We do only select $A$ tuples here in order to emulate the bottleneck of consciousness, although we are experiencing a bubble of data at each time $t$, we are only aware of a subset of this information, represented here by these tuples.

In order to make the decision of what is the tuple that I am most interested, that is, the action that I want to make at time $t+1$ and the action that needs to be ordered to do to the motor system, the global workspace assigns weights to every module involved in the decision, representing the importance that we consciously give to our instincts, represented by the attentional system $a(\cdot)$ and weighted as $w_a$; to the short term memory beliefs (if that tuple is contained in the set of short term memory beliefs) $w_s$ and to the long term memory $w_l$ these weights must sum $1$.

Every action $(m_l,s_k)_a$ will be assigned the following punctuation \\ $g(a(\cdot)|a(\mathbf{x}|\mathbf{w}), s(\mathcal{B}_s), s(\mathcal{B}_l), h(t), t) = f_h(w_a a(\cdot) + w_s s + w_l l|h)$, where $a(\cdot)$ is the importance given to the tuple by the attentional system, $s=1$ if the short term memory has determined that the tuple is positive and $s=-1$ if it is negative, $l=2$ if the long term memory has determined that the tuple is positive and $l=-2$ if it is negative. The function $f_h$ depends on the result of this operation and the degree $h$ of happiness. If the robot is in a good state, for example $h>5$, scores are not modified to encourage exploration. If it lies in a risk state $h<5$ and $h>\tau+\epsilon$, then the scores are modified by doubling the best score and decrementing to a half the worst score. If the situation is critical $h \in [\tau, \tau+\epsilon]$ the score given to the best tuple is $1$ and the other tuple recieves value $0$ just to focus on the best tuple.

The final decision is also done probabilistically, simulating rational doubts. Scores of the $A$ tuples are normalized with respect to its sum are recomputed as: $w_a = \frac{w_a}{\sum_{a=0}^{A} w_a}$. Then, we select at random from the multinomial distribution given by that weights.

At the beginning each module is initialized a weight uniformly. The global workspace then outputs the selected tuple to the perception system in order for it to inform the values of the sensor to the evaluation system and to the motor system to move to the new position $m_l$ and measure the sensor $s_k$.

The weights of every module $w_a,w_s,w_l$ are updated depending on the reward given by the evaluative system. If the criterion chosen by the attention was positive, the attention weight is incremented by $0.05$ and the others decremented and normalized as in the attention module. The contrary operation is done if the reward is negative. If stored beliefs corresponding to the selected tuple exist in the memories and they have the same criterion as the evaluative system, the memories are updated by the same mechanism as in the previous weight and viceversa. The update procedure is done iteratively and with a random order to not give preference to any particular module. This global workspace process corresponds to the System 2 module described in the Kahneman architecture \cite{kahneman2011thinking}.

Finally, the goal of the evaluative system is to evaluate the current information fed by the perceptual system that the global workspace has selected $f(g(\cdot)| \mathbf{p})$, this evaluation modifies the degree of happiness, which is the feeling that is being optimized and it can generate beliefs that can be stored in the short-term and long-term memories. Once an action is decided to be taken by the global workspace, the observed physical magnitude that has been used in this decision is sent to the evaluative system to be potentially remembered as experience if the evaluation $f(\cdot) > \beta_s$ and $f(\cdot) > \beta_l$ for the short and long term respectively. Also, depending on $f(\cdot)$ the weights of the attentional system and the global workspace are modified as it has been described in their respective sections of this manuscript.

The operation performed by the evaluative system is the following one. First, we apply the preference function that corresponds to the sensor $s_k$ that the perceptual system has measured, that is $r = \mathbf{p}_k(s_k(g_{ij}|t))$, obtaining the reward $r$ that modifies the happiness degree.
\section{Cognitive architecture}
As we have seen by the modules involved in the architecture, our proposed cognitive architecture is heavily inspired on the global workspace model \cite{dehaene1998neuronal}. The robot takes a decision based on several modules: long term and short term memory, an attentional system that filters information which is not relevant and its degree of happiness. The attentional system recieves a big set of information coming from the sensor of the agent in an analogy of the information coming from the senses that enter our brain. Despite the big amount of information that the senses perceive we are not conscious of all the information in each instant of time. We make our conscious decisions based on the information that we consciously perceive, which is a subset of the information processed by the brain. The unconscious mind filters the information that it considers to be useless for the conscious mind. Figure \ref{fig:arch} shows the structure of the cognitive architecture.
\begin{figure}[htb!]
\begin{center}
\includegraphics[width=0.75\textwidth]{global_workspace.pdf}
\caption{Architecture of the models described in the Model section}
\label{fig:arch}
\end{center}
\end{figure}
\section{Philosophy of mind connections}
Artificial consciousness can be seen as a sub-field from philosophy of the mind since the potential success of the implementations provided by the field depend on the assumptions made by functionalism, one philosophy of mind theory that is described on this section. Hence, it is important to review some philosophy of mind ideas and how the model proposed in this work is related  or could be a proper implementation of these ideas.

We will first consider Descartes dualism \cite{rozemond2009descartes}, where the mind is a separate entity than the body. In the dualism theory, the mind is a witness of the information that the senses coming from the physical world through the senses of the body give it. Let us define the information processing processes as System 1 and the conscious-self process as System 2 \cite{morewedge2010associative}. In our proposed system, we emulate the Descartes mind through the System 2 process, which emulates the conscious-self, that could emerge from another realm as Descartes states. The attentional, or unconscious emulator, system and the memories databases feed with information the conscious-self, being apart from others. Hence, if consciousness may arise from a system that process information as the human brain does and this process is independent from the rest, it could emerge in this process according to this theory. We could see the System 2 process as the viewer of a theatre \cite{baars1997theatre}, where the information is processed according to the global workspace model \cite{newman1997neural}.

If we consider, as in dualism in the extreme position of defining consciousness as a process that belong to a non-physical realm \cite{clarke2003descartes}, that the experiences that we feel are related with psychical, or non-physical properties that just correlate with brain processes, we can define these properties as qualia \cite{jackson1982epiphenomenal}.

On the other hand, we find the physicalism theory, that basically defines that the mind states are a direct physical representation of our mental states, or the experiences that we feel \cite{nagel1965physicalism}. If mental states are not only correlated but completely explained by physical states we would be assuming that the identity theory is true \cite{smart2009identity}. Hence, if we could program those physical states in a machine, mental states may automatically arise in response to them. The states may be programmed, as in this proposal, as the level of an indicator and the weights of an adaptive system. These states activate in response to environmental stimuli and in doing so they causally impact on our behaviours \cite{kim2018philosophy}. We could argue that biological beings would only be the ones that develop consciousness but an objection resides in the fact biological beings are develop by DNA, which is essentially a code. If we are seen as machines \cite{searle1990brain} being developed by DNA \cite{dennett1996darwin}, why would not an agent as the one described in this work be able to develop consciousness as well?

But we could argue that consciousness may only arise in biological beings, due for example to chemical reactions and not in computers that implement Turing machines \cite{eliasmith2002myth}. If we assume that consciousness can emerge independently of the materials and reactions but dependently on the physical states and the functional processing of information, then, artificial consciousness could be implemented in computers. This is basically what functionalism defends \cite{lycan1974mental}. In functionalism, the mental state is defined by its position on a causal chain and its dependant on external estimuli, previous behaviour and mental states \cite{hierro2005filosofia}. The mental states are functional states, transformations performed over representations. In this case our robot has as mental states the ones given by its position, its memories, its happiness state and the weights given by the attentional system. Pain and other emotions could be simulated with other thresholds than can vary through the information recieved by sensors, emulating our senses.

We could only assume that the proposed model or a generalization replacing all the adaptive systems based on weights by deep neural networks can make consciousness emerge if we agree with functionalist point of views. We can find in the literature which are the main objections to the functionalism theory \cite{block1978troubles,eliasmith2002myth}.

Other views on the mind include logical behaviorism, which basically states that the external behaviour of an agent explains its mental concepts \cite{kitchener1999logical}. That is, they are correlated. This thesis is the base of emulating consciousness in computers by simulating the correlated behaviours that humans perform when they are conscious \cite{merchan2020machine}. In this work the robot performs movements according to its memories and the level of the happiness indicator. We could predict how happy is the robot based on its decisions. This is an example of how mental states could be a mirror of external behaviours. The movements performed by the robot are also rational \cite{harman2013rationality} in the sense that they are a logical implication of internal and external outputs, as in conscious beings.

Other discussed theory for machine consciousness apart from the global workspace theory that could make machines conscious is the integrated information theory \cite{tononi2016integrated}. This theory is based on the following axioms of consciousness: It has intrinsic existence, my experience exists from my own intrinsic perspective; it has structure, it has to process a certain amount of information, it is integrated and excludes information. This amount of information is called the integrated information that the system must process in order to be conscious. The system would need to autonomously process cause and effect relations, which related to intrinsic perspective. These relations must affect the whole system to be structured, excluding non necessary information and being irreducible. Our proposed method is not based on this theory but in our robot the decisions taken have their cause on the happiness degree and the environment, having an intrinsic perspective. Then the robot makes a move based on that decision. We exclude from the decision taken by the System 2 process the information that the attentional or unconscious system qualifies as not important giving its weights. Following this reasoning, but excluding the idea of the minimum amount of information processed by an agent to be conscious, we also have influence from the integrated information theory.

It is arguable nonetheless that our agent performs behaviour with intentionality \cite{searle1983intentionality} or free will \cite{van1983essay}, as it is completely determined by the weights of the attentional system, the environment and the other modules. However, if we view this with a physicalist point of view \cite{jacob2003intentionality}, it would also be arguable that we perform our actions with free will as they would also be governed by the same things (unconscious filter of information entering from our senses, memories and levels of feelings as in the happiness case of our agent). Although, it seems to us that we can still have the freedom to decide \cite{jaworski2011philosophy}, which is the action that we model with the System 2 process in our agent. So, as we cannot directly measure consciousness in a system, it is hard to determine whether an agent has free will or intentionality from our point of view. It is important to distinguish consciousness from intelligence, so the Turing test \cite{saygin2000turing} or other measures of intelligence such as the Winegrad schema \cite{levesque2012winograd} are not related to determining whether an agent is conscious of itself.

Possible enhancements of our agent reside in being able to process abstract complex data representations as in the consciousness prior architecture \cite{bengio2017consciousness}. In this architecture, an attention neural network \cite{vaswani2017attention} sums up the information that the sensors of a robot perceive into a complex abstract representation of it that is processed by another deep neural network which entries are the output of the attention neural network and information coming from memories and the representations of the network at the previous instant of time. We agree in modelling cognitive architectures following these principles and it would be interesting that our robot would also learn these abstract representations. Another example is a machine consciousness architecture using deep learning and Gaussian process to emulate behaviors seen in humans when they are conscious \cite{merchan2020machine}.
\section{Experiments}
In this section, we provide a big set of experiments to provide empirical evidence of the advantages that cognitive architectures such as the one described in this work could give to agents.

We first define the environment that our model will interact with is represented as a list of $m$ magnitudes each of one can be represented as a bi-dimensional grid of size $N \times N$. Also, one condition that was established is that there should not be high differences in the magnitude value of any pair of adjacent cells. Each position of the grid holds several values $m$ that every sensor of the robot measures. A tri-dimensional grid is instantiated with size $N \times N \times m$. Each cell of the environment grid is initiated with a random real number, which is calculated using a normal distribution $\mathcal{N}(0,1)$. For each magnitude, all the values assigned to its bi-dimensional grid are normalized so their values lay within the interval $[-\alpha, \alpha]$. We generate multiple random environments with a different size of the grid $N=[20,100,200]$, whose first magnitude can be seen on Figure \ref{small_env_example} and number of magnitudes $m=[5,20,100]$. These environments are identified by ESxMy. Where $x$ is the grid size and $y$ the number of magnitudes.
\begin{figure}[htbp]
\centering{
\includegraphics[width=5cm]{include/env_example_size-20.png}
\includegraphics[width=5cm]{include/env_example_size-200.png}
}
\caption{Heat map of the first magnitude values of the environment ES20M5 and ES200M5.}
\label{small_env_example}
\end{figure}
In order to interpret the magnitude values into preferences, it is necessary to define the preference functions related to each magnitude. All of the defined functions satisfy that any magnitude value within $[-10, 10]$, returns a preference value within $[0, 10]$, with a preference of $0$ being the worst possible result for the agent and viceversa. The analytic expression of these functions are $ f(x) = |10 \cdot \sin{\left(\dfrac{x}{10} \cdot \dfrac{\pi}{2}\right)}|$, $f(x) = |10 \cdot \cos {\left(\dfrac{x}{10} \cdot \dfrac{\pi}{2} \right)}|$, $f(x) = 5 + 5 \cdot  \sin{\left(\dfrac{x}{10} \cdot \dfrac{\pi}{2} \right)}$ and $f(x) = -\cos{\left(\dfrac{x - 1}{10} \cdot \dfrac{\pi}{2} \right)}$.

The absolute sine function, gives a higher preference to extreme values, while giving a lower preference to magnitude values close to zero. The absolute cosine function has the opposite behaviour to the absolute sine function. This function is good for mapping most of the physical magnitudes that can be found in real life, for example temperature, since extreme values are, by definition, quite extreme and bad for both life and computational agents. The sine function, returns a higher preference for higher magnitude values and the additive inverse sine function, which acts as the opposite of the sine function. The preference functions are mapped to magnitudes randomly.

To be able to determine how good our model is performing, it is necessary to first define the evaluation metrics that are going to be used: FH: Final happiness. MH: Mean happiness. HSD: Happiness standard deviation NI: Number of iterations. WGFP: Weighted goodness of final position. MWG: Mean weighted goodness. MTI: Mean time per iteration (milliseconds). The final happiness is able to tells us how good was the agent at the moment of reaching the end of its path. The mean and standard deviation happiness are calculated with all happiness values obtained at each iteration of the simulation. Another goal of the model is to design agents that are able to localize and travel to the best possible position inside its environment, which is defined by the position that returns the best values of goodness for all of the magnitudes of the environment, using their corresponding preference functions. The global goodness of any position will be equal to the mean of all goodness values for each different magnitude. The sum of weights assigned to all four observations for one magnitude, one for each possible action, is considered the importance that is given to such magnitude at any specific iteration. Therefore, this value will be used as a weight for that magnitude at the moment of calculating the weighted goodness of the position of the agent.
The weighted goodness of the final positions is a good metric to evaluate how effective was the agent navigating into a position that satisfy its own idea of what is a good position.

The presented model has multiple variables that need to be defined for each simulation. Each parameter is tuned individually in all the environments according to several metrics. The initial parameters values considered are shown bellow: Number of iterations = $100$. Initial degree of happiness = $5$. Fatigue = $0.1$. Death threshold $\tau_{d} = 2$. Critical near death threshold $\tau_{c} = 3$. Risk threshold $\tau_{r} = 4$. Attentional conscious limit = $2$. Short-term memory capacity positions = $3$. Short-term memory threshold = $2$. Long-term memory capacity = $2$. Long-term memory threshold = $4$. Adaptation weights = $[0.05, 0.1, 0.2]$.

After initializing all variables with the values described, the model was tested against all the nine environments defined before. The obtained results can be observed at the table \ref{initial_param_eval}.
\begin{table}[htbp]
\small
    \centering
\begin{tabular}{l|rr|rrrrr}
\toprule
       ENV &     MH &    MWG &      FH &    HSD &   NI &   WGFP &    MTI \\
\midrule
    ES20M5 & 8.3425 & 3.2180 &  8.0033 & 2.0070 &  100 & 2.4248 & 0.3700 \\
   ES20M20 & 8.5641 & 2.3737 & 10.0000 & 2.0624 &  100 & 2.6874 & 0.6400 \\
  ES20M100 & 7.8666 & 3.3172 &  6.3860 & 1.7848 &  100 & 3.6951 & 2.3700 \\
   ES100M5 & 3.4002 & 6.5684 &  1.9108 & 1.0258 &   18 & 6.3144 & 0.3333 \\
  ES100M20 & 4.9274 & 3.6557 &  6.8798 & 0.9812 &  100 & 2.8410 & 0.7500 \\
 ES100M100 & 7.9255 & 2.0716 &  9.6474 & 2.4830 &  100 & 1.1165 & 2.7100 \\
   ES200M5 & 8.4133 & 1.6965 & 10.0000 & 1.8782 &  100 & 0.0932 & 0.4500 \\
  ES200M20 & 8.8552 & 1.6618 & 10.0000 & 1.9101 &  100 & 0.4386 & 1.4000 \\
 ES200M100 & 8.5203 & 2.6202 & 10.0000 & 2.0038 &  100 & 2.8214 & 2.5200 \\
 \midrule
 MEAN & 7.4239 & 3.0203 & 8.0919 & 1.7929 & 91 & 2.4924 & 1.1125\\
\bottomrule
\end{tabular}
    \caption{Result of evaluating the model with the initial set of parameters}
    \label{initial_param_eval}
\end{table}
There are multiple conclusions that can be made after analysing these results. First, it can be seen that out of all nine environments that were used to test the agent, it was able to survive in eight of them, only dropping its happiness under the death threshold in one environment, ES100M5. The over all mean happiness is also pretty high.

The weighted goodness values of final positions can also be considered good. We can see that the highest MWG was the one obtained in the only simulation that ended with the agent death, which is the simulation performed in the environment ES100M5, with a MWG value of $6.5684$. Over all, all values of MWG are under $4$ for the eight surviving agents, and in two simulations the agent was able to achieve an WGFP under $2.0$, which is a very good result. There is a clear relation between the MTI and the number of magnitudes. This relationship is caused by the additional effort that has to be made by the attentional system in order to select the observations that will be passed to the global workspace. Even better results might be obtained after the calibration of all parameters of the model. In Figure \ref{avg_happiness_initial} is represented the average value of happiness over time for one hundred iterations in all environments.
\begin{figure}[htbp]
  \centering
  \fontsize{8}{10}\selectfont
  \includegraphics[width=150pt]{include/4_3_1_initial_parameters/average_happiness.pdf}
  \includegraphics[width=150pt]{include/4_3_1_initial_parameters/average_weighted_goodness.pdf}
  \caption{Average happiness (left) and weighted goodness (right) over a hundred iterations for the initial set of paremeters tested against the nine different environments}
  \label{avg_happiness_initial}
\end{figure}
It can be observed that the agent, in average, maintained its initial happiness, $5$, for around twenty iterations before its happiness started raising rapidly, up to the iteration sixty, when the agent maintained a constant value near $9$. Also, in Figure \ref{avg_happiness_initial} we can see the average weighted goodness over time.

We can see a constant improvement of the average weighted goodness, which starts at a initial value of near $5$, and progresses over time up to an average of near $2$. There are some up and downs, but over all the graph shows that the progression follows a linear improvement over time. Given this progression, it is interesting to see if a lower value of weighted goodness could be achieved with a higher number of iterations. We repeat this simulation with a maximum number of iteration set to $500$, obtaining a similar set of results as in the case of $100$ iterations. We observe that one more agent died before reaching the 500 iterations, the one related to environment ES100M20, at the iteration number $275$. We plot the average happiness and weighted goodness in Figure \ref{avg_happiness_500_iter}.
\begin{figure}[htbp]
  \centering
  \fontsize{8}{10}\selectfont
  \includegraphics[width=150pt]{include/4_3_2_calibrating_niter/average_happiness_niter-500.pdf}
  \includegraphics[width=150pt]{include/4_3_2_calibrating_niter/average_weighted_goodness_niter-500.pdf}
  \caption{Average happiness (left) and weighted goodness (right) over a five hundred iterations tested against the nine different environments}
  \label{avg_happiness_500_iter}
\end{figure}
It can be seen that there is a fast improvement during the first $100$ iterations and after this, however, agents seem to maintain on average a weighted goodness value between $1.0$ and $3.0$, and a happiness value between $9$ and $10$, converging. An interesting fact is that the direct relationship within happiness and the weighted goodness: when the latter goes down, so does the former. This can be observed in the section between the iterations $200$ and $300$. Therefore, the maximum number of iterations was set to $500$ for all the following simulations.

We now tune four happiness-related parameters exists in the model: fatigue, initial degree of happiness, and the two of the three happiness thresholds: critical near death threshold $\tau_{c}$, and risk threshold $\tau_{r}$.

The first happiness-related parameter to be tuned was the fatigue, which is a constant number that is substracted to the happiness of the agent in each iteration. We do not include more numerical results in tables for these parameters but talk about the conclusions extracted from of the experiments. In terms of mean happiness, a tendency to obtain higher happiness with lower values of fatigue can be noticed. In terms of mean weighted goodness, lower fatigue returns better results for all values. Still, we do not want a fatigue value that is too low, since we still want to punish agents that are performing bad for a long period of time. Therefore, it was decided for this analysis that the best value of fatigue was $0.05$.

The next parameter that was analyzed was the initial degree of happiness. As it was expected, a higher initial of happiness results in a higher mean happiness. The third happiness-related parameter that was tested was the risk threshold, $\tau_r$. There is not a noticeable change in performance when comparing the first two tested values, $4.0$ and $4.5$. The value for the risk threshold that was chosen due to resulting in a better performance was $4.5$.

Finally, the last happiness-related parameter that is tested is the critical near death threshold, $\tau_{c}$. The results for $\tau_{c} = 3$ and $\tau_{c} = 3.5$ does not have a noticeable difference. Using MWG as the decisive metric, the chosen for the critical near death threshold is $\tau_{c} = 3.5$. The attentional limit also takes an important role in the behaviour of the agent. It represents the number of magnitudes that is chosen by the attentional system in each iteration, which are later sent to the global workspace at the moment of taking a decision about which action to execute. Multiple simulations were executed testing five different values for the attentional limit, whose results can be seen in the table \ref{tuning_attentional_limit}.
\begin{table}[htbp]
\small
\centering
\begin{tabular}{r|rr|rrrrr}
\toprule
 attentional limit &     MH &    MWG &     FH &    HSD &       NI &   WGFP &    MTI \\
\midrule
1 & 7.9394 & 2.9516 & 7.2807 & 1.3820 & 373.0000 & 3.1601 & 1.0873 \\
2 & 8.7627 & 2.2434 & 8.1974 & 1.2392 & 431.4444 & 1.8643 & 1.1254 \\
3 & 8.6832 & 2.9691 & 8.0908 & 1.1957 & 425.5556 & 3.6208 & 1.1141 \\
4 & 8.4873 & 2.6407 & 7.4097 & 1.3014 & 444.2222 & 3.1423 & 1.1427 \\
5 & 8.8075 & 2.5964 & 8.1871 & 1.1160 & 435.3333 & 3.4292 & 1.1777 \\
\bottomrule
\end{tabular}
\caption{Mean results for different attentional limit values}
\label{tuning_attentional_limit}
\end{table}
The attentional limit $= 2$ has the best performance. Its value of mean weighted goodness, $2.2434$, is the lowest out of all, and its mean happiness, $8.7627$, is also very high, only improved by the mean happiness obtained with attentional limit $= 5$. We set the attentional limit to $2$.

Each of the memories of the agent has two parameters to be tuned, their capacity and the threshold. The first parameter that is analyzed is the short-term memory capacity. It can be seen that, MWG-wise, the best result is obtained with a capacity of five beliefs. We then proceeded with the other parameter of the short-term memory: its threshold, $\tau_{stm}$. In this case, it seems that decreasing the initial parameter from $\tau_{stm} = 2$ to $\tau_{stm} = 1.5$ produces slightly better results in terms of both mean happiness and mean weighted goodness, so the change is made permanent. We perform in an analogous way with the long-term memory. Here, it seems like there is a decent improvement of the model performance when increasing the long-term memory capacity from $2$ to $6$, going from a mean weighted goodness of $2.1758$ to $2.1025$. Regarding the long-term memory threshold, it seems like changing the initial values decrease the performance of the model. Therefore, the initial value of $\tau_{ltm} = 4$ stays intact.

Finally, the only parameters left to tune are the learning rates: the low learning rate, $\lambda_{l}$, the medium learning rate, $\lambda_{m}$ and the high learning rate, $\lambda_{h}$. Regarding the low learning rate, $\lambda_{l}$. It can be seen that changing the learning rate produces the higher difference in performance out of all the tested parameters, with a deviation of mean weighted goodness of almost $1$ when comparing some of the simulations. The best performance is found when the low learning rate is set to its initial value, $0.05$.

We set $1.5$ for the final value of the medium learning rate. Lastly, regarding the high learning rate we can appreciate that the lowest value of MWG is obtained with $\lambda_{h} = 0.4$, but as we want the agent to be alive in critical situations, we set it to $2$.

The results obtained for each of the nine tested environments, using the tuned set of parameters, are displayed in Table \ref{results_final_parameters}.
\begin{table}[htbp]
\small
\centering
\begin{tabular}{l|rr|rrrrr}
\toprule
       ENV &     MH &    MWG &      FH &    HSD &   NI &   WGFP &    MTI \\
\midrule
    ES20M5 & 9.6633 & 0.7233 & 10.0000 & 1.0984 &  500 & 0.0396 & 0.3760 \\
   ES20M20 & 9.4097 & 2.4639 & 10.0000 & 1.4519 &  500 & 1.8189 & 0.5760 \\
  ES20M100 & 9.6779 & 1.1043 & 10.0000 & 1.0570 &  500 & 0.0292 & 2.0100 \\
   ES100M5 & 3.2294 & 6.5653 &  1.9887 & 0.8067 &   20 & 6.5903 & 0.3000 \\
  ES100M20 & 9.5266 & 1.6654 & 10.0000 & 1.4315 &  500 & 3.0864 & 0.7060 \\
 ES100M100 & 9.5062 & 2.3734 & 10.0000 & 1.3311 &  500 & 1.1592 & 2.0680 \\
   ES200M5 & 9.5654 & 2.1843 & 10.0000 & 1.2407 &  500 & 2.2895 & 0.3300 \\
  ES200M20 & 9.7824 & 0.6477 & 10.0000 & 0.9607 &  500 & 2.6468 & 0.6760 \\
 ES200M100 & 9.7408 & 0.8837 & 10.0000 & 1.0270 &  500 & 0.5856 & 2.6000 \\
\bottomrule
\end{tabular}
\caption{Results of evaluating the model with the final set of parameters}
\label{results_final_parameters}
\end{table}
In order to analyze how well the final parameters perform compared to the initial set, both the average happiness and average weighted goodness over time have been plotted in Figure \ref{avg_happiness_final}.
\begin{figure}[htbp]
  \centering
  \fontsize{8}{10}\selectfont
  \includegraphics[width=150pt]{include/4_3_7_final_parameters/average_happiness_final.pdf}
  \includegraphics[width=150pt]{include/4_3_7_final_parameters/average_weighted_goodness_final.pdf}
  \caption{Average happiness (left) and weighted goodness (right) over a five hundred iterations comparing the final (solid line) and initial parameters (dotted line)}
  \label{avg_happiness_final}
\end{figure}
On average, the final set outperforms the initial en both metrics. We can observe that peak performance is achieved near the iteration $150$, when an average weighted goodness near $0$ is achieved. The average happiness also shows good performance, keeping a value of near 10 at the iteration $100$, and maintaining such value for latter iterations.

Recall that any value of goodness lower than 5 is considered good. In this experiment, agents have shown to be able to maintain in average goodness values between $0$ and $2$, which by the definition given, are very good values. Therefore, we can deduct that the model is well constructed and the agents are achieving the goal that were set for them.

We perform more experiments in five different simulations. In each simulation, nine new environments are randomly generated and each magnitude of each environment is assigned one of the four defined preference functions. The average results per each simulation can be found on the table \ref{results_eval}.
\begin{table}[htbp]
\small
\centering
\begin{tabular}{r|rr|rrrrr}
\toprule
 Simulation &     MH &    MWG &     FH &    HSD &       NI &   WGFP &    MTI \\
\midrule
1 & 7.9834 & 2.8295 & 7.2776 & 1.2497 & 349.6667 & 2.8194 & 1.1530 \\
2 & 8.9011 & 2.4198 & 8.1681 & 1.1666 & 442.7778 & 2.9534 & 1.1381 \\
3 & 8.7009 & 2.9118 & 7.2381 & 1.1820 & 390.5556 & 3.9969 & 1.0910 \\
4 & 9.4744 & 1.5601 & 9.1094 & 1.4773 & 481.6667 & 2.0276 & 1.1219 \\
5 & 8.7284 & 2.4389 & 8.2148 & 1.2845 & 416.4444 & 1.9841 & 1.1809 \\
\bottomrule
\end{tabular}
\caption{Evaluation of the final model in 5 different simulations, for each simulation showing the average result of 9 different environments.}
\label{results_eval}
\end{table}
The average happiness and average weighted goodness are also shown over time in the plots of Figure \ref{avg_happiness_eval}.
\begin{figure}[htbp]
  \centering
  \fontsize{8}{10}\selectfont
  \includegraphics[width=150pt]{include/4_4_results_eval/average_happiness_eval.pdf}
  \includegraphics[width=150pt]{include/4_4_results_eval/average_weighted_goodness_eval.pdf}
  \caption{Average happiness and weighted goodness of the final model over five hundred iterations, in 5 different simulations}
  \label{avg_happiness_eval}
\end{figure}
We observe that all the results are similar: they all have a starting learning curve in the first 100 iterations and then a constant performance is maintained. It can be seen that in none of the simulation the mean weighted goodness has a value higher than $3$ so we can determine that the model is having a good performance. This experiment proves the capability of the model to generalize to different environments. We conclude that the evaluation of the presented model achieves to maintain high values of happiness and low values of weighted goodness.
\section{Conclusions and further work}
Along this manuscript, a prototype of a potentially conscious model has been proposed which has shown to create autonomous agents able to navigate through environments. The results of executing multiple simulations with different sets of parameters and different environments allows us to determine that the presented model shows a proper behaviour, being capable to reach and maintain high values of happiness. We show how the possession of feelings have proven to be a powerful tool which grants the system multiple beneficial abilities. Feelings are a great representation of the conscious state of an agent, and could serve as an example of a self-model representation. Two main advantages are provided by such self-model. First, it gives the agents the capability to report its conscious state as any moment. Secondly, it gives the agents the opportunity to have an understanding of its inner state and act according it to adapt to multiple situations. Attention filters the information that is way too big to process as a whole, deciding which observations are relevant enough to become conscious and which do not. The memory system, used to store past experiences and beliefs, also reinforces the adaptation ability that makes the agents able to learn from previous mistakes and successes. Using two different memories gives a higher degree of depth to this system. Finally, the global workspace, where decisions are made, has the information processed by the rest of the modules is integrated. If consciousness could exist within this model, it would lay here.

As further work, we can implement more complex environments where the robot would need to interact in complex ways with the environment to remain alive. We will also implement deep neural networks for all the adaptive systems and memories of the robots, expanding and implementing the model in the same fashion as in the consciousness prior. As we have seen, the model has several parameters but we do not have an analytic expression to optimize them and computing the mean results can be expensive. Bayesian optimization has been used with success in similar problems \cite{garrido2018suggesting,cordoba2018bayesian}. In particular, we could optimize several metrics simultaneously under the presence of constraints such as the robot not dying with a constrained multi-objective Bayesian optimization approach \cite{fernandez2020max,garrido2020parallel}. Finally, we will implement several levels of feelings in the robot, for example: hungry, social needs or need to dream. The robot actions will be a function of that feelings along with happiness in a multi-objective problem where the robot will need to keep the level of all its indicators above some threshold.
\bibliographystyle{acm}

redpajama_set_name: RedPajamaArXiv


Head to Mallory Park for a triple supercar thrill that will never be forgotten. Take to the track with an instructor for a safety briefing to learn about the twists and turns of the circuit, plus racing lines and special driving techniques. Then take the wheels of the Aston Martin DB9 or V8 Vantage, the Ferrari 360 or 430 and the ferocious Lamborghini Gallardo. All very different, but each exceptional in its own way, driving these blisteringly fast cars is an amazing chance that very few get, and drivers get six miles in each! When the driving is over and the adrenaline starts to subside, pick up a memento certificate to take home as a souvenir.


OK. I'll hold my hand up and admit it.. I have a hotmail.com email address. But, in mitigation, I don't use it that much. Very little, in fact. I use windows messenger a little, and occasionally contacts on there send me emails which default to the hotmail inbox. Oh, and my O2 online bills go there, as I signed up to them many years ago when I was changing hosting on my own domians and couldn't rely on getting the emails. As it's always a fixed amout, and I can check it on O2's website, I don't usualy have need to read the emails.
Anyway, one such contact sent me an email the other day, prompting me to log into hotmail for the first time in ages to get the message. Wherupon I suddenly realised that there was very little mail in the account, and my folders with old stuff, including all my O2 bills, had gone!
Apparently my account had been marked "inactive".
The contents of your MSN Hotmail inbox were deleted by an automated service which flags accounts which have not been signed into for 60 or more days. Once the inbox contents have been deleted, they cannot be recovered.
When you signed in after that period of inactivity, you were also upgraded to Windows Live Hotmail. Windows Live Hotmail will keep your account active, even if you do not sign in for 120 days.
Please be guided that logging into other Windows Live ID or MSN services does not count as Hotmail activity.
So, there you have it. If you don't use hotmail very often, make sure you at least login every six weeks or so, or you'll lose everything!
At least I didn't loose too much, but I'll be making sure nothing uses that account any more.


I like this definition – not because I'm a humble person, it's something I can struggle with just the same as most others. It's easy to NOT be humble, something good happens and BAM! we want to proclaim it for all to see. However, looking at God's word, and looking at the definition of what humble means shows us that those temptations to boast and brag are not godly traits. It isn't our job to lift ourselves up and declare to the world our own greatness or accomplishments. Doing so may get us a few likes and a few pats on the back, but waiting on God to do the lifting will lead to something far great which will, in the end not only give us 'glory', but ultimately, Him.
Today, let our prayer be these words in 1 Peter 5:6. Let us pray together that God help our students as they prepare to go back to school to have a humble heart and spirit. That they would not seek the praise of their peers, but they would be humbly submitted to their Heavenly Father seeking his applause, and his alone.


Elvis' Golden Records is the fifth album by Elvis Presley issued by RCA Victor in March 1958. It is a compilation of hit singles released in 1956 and 1957, and is widely believed to be the first greatest hits album in rock and roll history. It is the first of five Elvis' Golden/Gold Records compilations, four of which would be released during Presley's lifetime. It peaked at number three on the Billboard Top Pop Albums chart. It was certified Gold on October 17, 1961, Platinum on May 20, 1988, 5x Platinum on March 27, 1992 and 6x Platinum on August 17, 1999 by the Recording Industry Association of America.


By leveraging outside expertise for the maintenance and optimization of the current system, the hospital can reassign key resources to the implementation of the new application. The same philosophy holds true with implementation of the new application. Due to the complexity and needs of the project, the use of experienced outside consultants plays a key role in meeting project objectives and timelines. The key is to leverage the expertise of the consultant in collaboration with the hospital team and the vendor.
Development of change control processes and domain management.
Are the order sets being used by the providers? If not, why? Is there a training issue? Do the order sets need to be modified for more effective utilization?
Understanding how the modules/components impact each other.
"At the elbow" support of end-users.


The HP-45 was HP's third handheld electronic calculator and the second scientific model. Early advertising brochures touted the HP-45 as doing "So much more. More than even our first "electronic slide rule!" The HP-45 added many advanced features to the HP's first scientific calculator, the HP-35, including a built-in timer mode.
Why don't you guys try using my calculator. It's much cooler than yours.
I'm Ladislav from Prague, Czech Republic. I'm former HP support service man. I still own some spare parts and manual for your broken HP45 and might be able to repair it. Depends on the error type. Leave me an email if you are interested.


About Us - Kids Ride On Car,Kids Electric Car Toy Supplier,Manufacturer And Factory.Kids Toy Wholesale.
Opecars Industrial Co,.LTD is one of the Top 3 kids ride on toy manufacturers in China, which specializing in manufacturing and marketing of Kids ride on car, Kids pedal car, Kids ride on Quad/ATV, Kids motorcycle.
Opecars Focus on kids ride on toys for more than 10+ years.Top 3 brand with CE, ASTM F963, EN71-1-2-3, EN62115 etc., enjoy high reputation from our customers all over the world.We provide high quality products and VIP service.
Opecars have a well team-conscious, the ability of communication and coordination, work hard, meticulous and patience can afford the pressure of the work. We are young, passionate, fun, experienced, helpful, when doing business with us, there is nothing you cannot rest assured.
Currently we have major customers from all over the world, especially from Europe and South America. Provide cost efficient yet quality products for our customers, assisting them to gain competitive advantages are our major focus.
Main Products: Licensed ride on cars,Licensed pedal cars,Kids ride on Quad/ATV,Kids motorcycle.
Certifications: CE, ASTM F963, EN71-1-2-3, EN62115 etc.
We currently have 4 main products, Licensed kids ride on cars, Licensed kids pedal cars, Kids Quad/AVT, Kids ride on Mortorcycle. Our products comes with CE, ASTM F963, EN71-1-2-3, EN62115 certifications etc.Our products had been exported to the countries all over the world and especially in America, South America, European countries and enjoy high reputation from our customers.
We have QC technicians conducting piece-by-piece double testing on finished products. All products will be tested more than 24 hours before shipment. Four inspection stages occur during production and a final product testing process is a prerequisite prior to packing ensuring a defective product percentage as low as 0.1%.
Top sales with professional skills make you never feel difficult to communicate with a factory, all Opecars staff will stand by you, reply your inquiry and solve your problem, no matter pre-sales or after-sales. All your emails will be replied within 24 hours.


Yand Yont Phand Co., Ltd.
Yala Chalearn Kij Ltd., Part.
Yb Integrated Solutions Co., Ltd.
Ying Yong Sale And Service Co., Ltd.
Yingcharoen International (Thailand) Co., Ltd.
Ying Yoen Yong Karnchang Ltd., Part.
Ylg Bullion & Futures Co.,ltd.
Ymn Engineering And Service Co.,ltd.
Yn & Ks Ltd., Part.
Yong Kang Chinese Medicine Co.,ltd.
Yong Seng Rice Mill Ltd., Part.
You Hsien Interwational Co., Ltd.
Yp Engineering And Services Co.,ltd.
Yss Intertrade Corporation Co., Ltd.
Ysl Supply & Print Co., Ltd.
Ys Supply Screw Not Co., Ltd.
Yu Fong International Co., Ltd.
Yul Gok Golf (Thailand) Co.,ltd.
Yves Privas International (Thailand) Co., Ltd.
Yw Air Sale And Service Ltd., Part.


text:
Shakur Stevenson earns stoppage, Joshua Greer gains decision
RINGSIDE 14/07/2019
📷 Mikey Williams
Ever since he turned pro following the 2016 Olympics, featherweight contender Shakur Stevenson wanted to return home to Newark. In front of 5,150 fans at Prudential Center, Stevenson, the WBO No. 1 contender, knocked out two-time world title challenger Alberto "Metro" Guevara (27-5, 12 KOs) in the third round of a scheduled 10-rounder.
"That was a great performance I put on for the city of Newark. Top Rank, y'all all have to give me better competition I want the IBF and WBO {titles}. I would love to go to England to fight Josh Warrington," Stevenson said. "I surprised myself today. I was going to the body a lot. I saw him at the weigh-in. He didn't look like he was in shape.
"There is only one way to describe tonight – amazing! Seeing all of my family, friends and everybody from the city come out to support me was incredible."
Stevenson (12-0, 7 KOs) dominated the opening round, scored a pair of knockdowns in the second and finished things off with a knockdown in the third. It was a short, brutal and just what the crowd wanted.
Greer Jr. Edges Potapov
The knockout didn't come, but bantamweight Joshua "Don't Blink" Greer Jr. ultimately got the job done. Greer (21-1-1, 12 KOs), the Chicago-born bantamweight puncher, bested Nikolai Potapov by majority decision (114-114, 115-113 and 116-112) to the earn the IBF No. 2 ranking and the NABO belt.
Greer swept the 12th round on all three judges' scorecards to secure the win in what was a tactical affair. Potapov (20-2-1, 11 KOs) snapped Greer's seven-bout KO streak, with some ringside observers believing he did enough to pull off the upset.
"He's very awkward with the Russian style. But at the end of the day, this is the pros. And at the end of the day, I pulled it out," Greer said. "The booing didn't bother me. I know I won the fight. Every time I hit him to the body, I hurt him. I didn't get the knockout, but I got the win. Next time out, you'll see the pillow again."
In other action:
After nearly two years out of the ring, super lightweight Julian Rodriguez (17-0, 11 KOs) needed only 59 seconds to knock out Hevinson Herrera (24-18-1, 18 KOs) in front of his devoted Northern New Jersey fans.
Rodriguez, only 24 years old, was out of the ring due to assorted injuries.
"I was very confident in my preparation, so I felt like I had to go in there and do what I had to do," Rodriguez said. "That's what {the fans} like about me. When they come here, they see a show."
— Vijender Singh (11-0, 8 KOs), a three-time Olympian and the fighting pride of India, had a successful United States and Top Rank debut, knocking out Mike Snider (13-6-3, 8 KOs) in the fourth round of a scheduled eight-round super middleweight bout.
"It was excellent getting back in the ring after a long time off. It's great to be here in the USA and get the win. It was really exciting," Singh said. "It took me about four rounds to get back in the swing of things. I expected it to take two or three rounds, but it took me four. I felt good."
— Joseph "Blessed Hands" Adorno (13-0, 11 KOs) continued his rapid rise up the lightweight ranks, knocking out Adriano Ramirez (10-4, 6 KOs) in the second round of a scheduled eight-rounder. Adorno knocked down Ramirez a pair of times in the second, and referee Sparkle Lee immediately called a halt to the bout following the second knockdown.
— Josue "The Prodigy" Vargas (14-1, 9 KOs) won his eighth fight in a row, knocking out the rugged veteran Manuel Lopez (14-4-1, 7 KOs) in the seventh round of a scheduled eight-round welterweight bout.
— Super lightweight prospect John "El Terrible" Bauza (13-0, 5 KOs) was dominant in notching an eight-round unanimous decision over Angel Sarinana (10-9-2, 4 KOs) by identical scores of 80-72.
— Vito Mielnicki Jr., a 17-year-old high school senior from Roseland, New Jersey, knocked out Tamarcus Smith (2-3, 2 KOs) in 1:16 in his professional debut. A savage right hand put Smith down and out for the count in the scheduled four-round welterweight bout.

redpajama_set_name: RedPajamaCommonCrawl


From Our Community. For Our Community.
At a time when it feels like politicians have lost touch with our priorities, our values, and simple common sense, we have a chance to elect a State Representative who understands our communities and our priorities.
Anna Williams is a social worker, teacher, community leader, and a mom who brings people together to make a real difference. Like so many of us, she and her family came to Oregon because there is no better place to live, work, and raise a family.
She is running for State Representative to protect our quality of life, preserve our spectacular natural heritage, and grow our local economy. Anna works as an academic adviser to social work students at Simmons College. Her social work in Hood River and surrounding communities has focused on services to vulnerable seniors, trauma survivors, and veterans. She has also taught middle and high school students in the Hood River, North Wasco, and Dufur School Districts, giving her real-world experience in what students and classrooms need.
Anna's experience includes building sustainable tourism economies for communities like Hood River and Cascade Locks across Oregon. She also worked in non-profits which focus on safety for women and children, senior services, and health care, building effective partnerships with law enforcement, courts, schools, and public health so that every person in the Gorge can access the basic services they need to survive and thrive.
Anna has the values, experience, and community connection that's missing in Salem.
This is why Anna should be our next State Representative.
Starting in 2016, Anna teamed with a diverse group of community members to found the Aging in the Gorge Alliance, to align and support efforts to create local solutions to the challenges facing older adults in this rural part of the state. Anna was then nominated to Chair, responsible for coordinating the work of multiple groups working on transportation, housing, and health care solutions.
Anna has served on other boards as diverse as the Montana Wilderness Association, Little Feet Preschool, and the Senior Advisory Council of the local Area Agency on Aging.
In the summer of 2017, Anna was recruited to serve as an Academic Advisor and instructor for Social Work students from around the country. Working from Hood River for Simmons College, headquartered in Massachusetts, she teaches online courses, provides academic advising, and manages a support group for Military Involved students who are pursuing a Masters' Degree in Social Work.
Anna has the skills and vision to take the next step in her public service. It is time for Anna!
Pass common sense gun control like the assault weapons ban and safe storage laws.
Fight to keep abortion safe and legal for all women in Oregon.


This template can be used for a mini-writing lesson after Thanksgiving break. It can be turned into a short poem or a mini-narrative.
I use these 5 sense-writing formats to emphasize the importance of word choice (descriptive words, adjectives, detail, etc.) and to review appropriate verb choice after each sense.


text:
import Queue
import argparse
from datetime import datetime
import fnmatch
import time
import json
import subprocess
import tempfile
import sys
import threading
import traceback

import boto
from boto.s3.connection import OrdinaryCallingFormat
from boto.s3.key import Key
import etcd
import os

class DeisBackupRestore:
    _etcd_connection = None
    _base_directory = None

    _data_path = '/data/'

    _max_spool_bytes = 1000000

    def __init__(self, aws_access_key_id='', aws_secret_access_key='', host='s3.amazonaws.com', port=443,
                 is_secure=True, bucket_name='deis-backup', etcd_host='127.0.0.1', etcd_port=4001, no_data=False, dry_run=False):
        self._remote_access_key = aws_access_key_id
        self._remote_secret_key = aws_secret_access_key
        self._remote_host = host
        self._remote_port = port
        self._remote_is_secure = is_secure
        self._remote_bucket_name = bucket_name
        self._etcd_host = etcd_host
        self._etcd_port = etcd_port
        self._no_data = no_data
        self._dry_run = dry_run

    def get_base_directory(self):
        if self._base_directory is None:
            self._base_directory = datetime.now().strftime("%Y-%m-%d-%H:%M")
        return self._base_directory

    def get_etcd_connection(self):
        if self._etcd_connection is None:
            self._etcd_connection = etcd.Client(host=self._etcd_host, port=self._etcd_port)
        return self._etcd_connection

    def get_etcd_value(self, key, default=None):
        try:
            return self.get_etcd_connection().read(key).value
        except:
            return default

    def set_etcd_value(self, key, value, ttl=None):
        return self.get_etcd_connection().set(key, value, ttl)

    def get_deis_s3_connection_args(self):
        host = self.get_etcd_value('/deis/store/gateway/host')
        port = self.get_etcd_value('/deis/store/gateway/port')
        aws_access_key_id = self.get_etcd_value('/deis/store/gateway/accessKey')
        aws_secret_access_key = self.get_etcd_value('/deis/store/gateway/secretKey')
        return {
            'aws_access_key_id': aws_access_key_id,
            'aws_secret_access_key': aws_secret_access_key,
            'host': host,
            'port': int(port),
            'is_secure': False,
            'calling_format': OrdinaryCallingFormat()
        }

    def get_remote_s3_connection_args(self):
        return {
            'aws_access_key_id': self._remote_access_key,
            'aws_secret_access_key': self._remote_secret_key,
            'host': self._remote_host,
            'port': self._remote_port,
            'is_secure': self._remote_is_secure,
            'calling_format': OrdinaryCallingFormat()
        }

    def get_deis_s3_connection(self):
        return boto.connect_s3(**self.get_deis_s3_connection_args())

    def get_remote_s3_connection(self):
        return boto.connect_s3(**self.get_remote_s3_connection_args())

    def get_deis_s3_bucket(self, bucket_name):
        return self.get_deis_s3_connection().get_bucket(bucket_name)

    def get_remote_s3_bucket(self):
        return self.get_remote_s3_connection().get_bucket(self._remote_bucket_name)

    def get_deis_key_name(self, deis_bucket_name, remote_key_name):
        return remote_key_name.replace(self.get_base_directory() + '/' + deis_bucket_name + '/', '')

    def get_remote_key_name(self, deis_bucket_name, deis_key_name):
        return '/' + self.get_base_directory() + '/' + deis_bucket_name + '/' + deis_key_name

    def backup(self):
        started_at = datetime.utcnow()
        try:
            self.backup_etcd()
            self.backup_database_sql()
            self.backup_database_wal()
            self.backup_registry()
            if not self._no_data:
                self.backup_data()
        except:
            ex_type, ex, tb = sys.exc_info()
            try:
                self.write_failure_file(traceback.format_exc())
            except:
                pass
            raise ex_type, ex, tb
        else:
            self.write_success_file(started_at, datetime.utcnow())

    def restore(self, base_directory):
        self._base_directory = base_directory
        self.set_router_body_size('2048m')
        self.restore_database_wal()
        self.restore_registry()
        self.restore_etcd()
        if not self._no_data:
            self.restore_data()

    def write_success_file(self, started_at, ended_at):
        bucket = self.get_remote_s3_bucket()
        key = Key(bucket, '/' + self.get_base_directory() + '/success')
        message = 'Started at ' + started_at.isoformat() + '\n'
        message += 'Ended at ' + ended_at.isoformat() + '\n'
        message += 'Took ' + str(ended_at - started_at)
        self.set_contents_from_string(key, message)

    def write_failure_file(self, message=''):
        bucket = self.get_remote_s3_bucket()
        key = Key(bucket, '/' + self.get_base_directory() + '/failure')
        self.set_contents_from_string(key, message)

    def set_router_body_size(self, size='1m'):
        key = '/deis/router/bodySize'
        self.set_etcd_value(key, size)

    def backup_database_sql(self):
        print('backing up database sql')
        env = os.environ.copy()
        env['PGHOST'] = self.get_etcd_value('/deis/database/host')
        env['PGPORT'] = self.get_etcd_value('/deis/database/port')
        env['PGUSER'] = self.get_etcd_value('/deis/database/adminUser')
        env['PGPASSWORD'] = self.get_etcd_value('/deis/database/adminPass')
        proc = subprocess.Popen('pg_dumpall', env=env, stdout=subprocess.PIPE)
        (output, err) = proc.communicate()

        bucket = self.get_remote_s3_bucket()
        key = Key(bucket, self.get_remote_key_name('other', 'database.sql'))
        self.set_contents_from_string(key, output)
        key.close()

    def backup_bucket(self, deis_bucket_name):
        print('backing up bucket ' + deis_bucket_name)

        pool = BucketThreadPool(4, self.get_deis_s3_bucket, deis_bucket_name, self.get_remote_s3_bucket)

        deis_bucket = self.get_deis_s3_bucket(deis_bucket_name)
        for key in deis_bucket.list():
            pool.add_task(self.backup_file, *(deis_bucket_name, key.key))

        pool.wait_and_shutdown()

    def backup_file(self, deis_bucket_name, key_name, deis_bucket=None, remote_bucket=None):
        key = Key(deis_bucket, key_name)
        remote_key = Key(remote_bucket, self.get_remote_key_name(deis_bucket_name, key_name))

        temp = tempfile.SpooledTemporaryFile(self._max_spool_bytes)
        key.get_contents_to_file(temp)
        self.set_contents_from_file(remote_key, temp)
        temp.close()

        key.close()
        remote_key.close()

    def restore_bucket(self, deis_bucket_name):
        print('restoring bucket ' + deis_bucket_name)

        try:
            print('creating bucket...')
            self.get_deis_s3_connection().create_bucket(deis_bucket_name)
        except:
            print('bucket already exists')

        print 'emptying bucket...'
        bucket = self.get_deis_s3_bucket(deis_bucket_name)
        bucket_list = bucket.list()
        bucket.delete_keys([key.name for key in bucket_list])

        pool = BucketThreadPool(4, self.get_deis_s3_bucket, deis_bucket_name, self.get_remote_s3_bucket)

        remote_bucket = self.get_remote_s3_bucket()
        for key in remote_bucket.list(prefix=self.get_base_directory() + '/' + deis_bucket_name + '/'):
            pool.add_task(self.restore_file, *(deis_bucket_name, key.key))

        pool.wait_and_shutdown()

    def restore_file(self, deis_bucket_name, key_name, deis_bucket=None, remote_bucket=None):
        key = Key(remote_bucket, key_name)
        deis_key = Key(deis_bucket, self.get_deis_key_name(deis_bucket_name, key.key))

        temp = tempfile.SpooledTemporaryFile(self._max_spool_bytes)
        key.get_contents_to_file(temp)
        self.set_contents_from_file(deis_key, temp)
        temp.close()

        key.close()
        deis_key.close()

    def set_contents_from_string(self, key, string):
        if self._dry_run:
            print('dry-run: not uploading ' + key.key)
        else:
            print('uploading ' + key.key)
            key.set_contents_from_string(string)

    def set_contents_from_file(self, key, file):
        if self._dry_run:
            print('dry-run: not uploading ' + key.key)
        else:
            print('uploading ' + key.key)
            key.set_contents_from_file(file, rewind=True)

    def get_contents_to_file(self, key, file):
        if self._dry_run:
            print('dry-run: not getting ' + key.key + ' to ' + file.name)
        else:
            print('getting ' + key.key + ' to ' + file.name)
            key.get_contents_to_file(file)

    def backup_database_wal(self):
        bucket_name = self.get_etcd_value('/deis/database/bucketName', 'db_wal')
        self.backup_bucket(bucket_name)

    def backup_registry(self):
        bucket_name = self.get_etcd_value('/deis/registry/bucketName', 'registry')
        self.backup_bucket(bucket_name)

    def restore_database_wal(self):
        bucket_name = self.get_etcd_value('/deis/database/bucketName', 'db_wal')
        self.restore_bucket(bucket_name)

    def restore_registry(self):
        bucket_name = self.get_etcd_value('/deis/registry/bucketName', 'registry')
        self.restore_bucket(bucket_name)

    def backup_etcd(self):
        print ('backing up etcd...')

        root_dir = self.get_etcd_connection().read('/', recursive=True)
        d = {}
        for entry in root_dir.children:
            d[entry.modifiedIndex] = {
                'key': entry.key,
                'value': entry.value,
                'ttl': entry.ttl,
                'dir': entry.dir,
                'index': entry.modifiedIndex
            }

        indexes = sorted(d.keys())
        dumplist = []
        for idx in indexes:
            dumplist.append(d[idx])

        bucket = self.get_remote_s3_bucket()
        key = Key(bucket, self.get_remote_key_name('other', 'etcd.json'))
        self.set_contents_from_string(key, json.dumps(dumplist))

    def restore_etcd(self):
        print ('restoring etcd...')
        bucket = self.get_remote_s3_bucket()
        key = Key(bucket, self.get_remote_key_name('other', 'etcd.json'))
        data = json.loads(key.get_contents_as_string(encoding='utf-8'))

        blacklist = [
            '/coreos.com/*',
            '/deis/builder/users/*',
            '/deis/cache/*',
            '/deis/certs/*',
            '/deis/config/*',
            '/deis/database/initId',
            '/deis/domains/*',
            '/deis/platform/domain',
            '/deis/platform/sshPrivateKey',
            '/deis/registry/hosts/*'
            '/deis/registry/masterLock',
            '/deis/router/hosts/*',
            '/deis/services/*',
            '/deis/store/*',
            '/registry/*'
        ]

        for entry in data:
            entry_key = entry['key'].encode('utf-8')
            blacklisted = False
            for blacklisted_pattern in blacklist:
                if fnmatch.fnmatch(entry_key, blacklisted_pattern):
                    blacklisted = True
            if not blacklisted:
                self.restore_etcd_value(entry)

    def restore_etcd_value(self, entry):
        if self._dry_run:
            print('dry-run: not setting ' + entry['key'].encode('utf-8') + ' => ' + entry['value'].encode('utf-8'))
        else:
            try:
                key = entry['key']
                if key is not None:
                    self.get_etcd_connection().write(key.encode('utf-8'), entry['value'].encode('utf-8'),
                                             ttl=entry['ttl'], dir=entry['dir'])
                else:
                    print('Failed to restore etcd entry: empty key')
            except:
                print('Failed to restore etcd entry')
                print traceback.format_exc()

    def backup_data(self):
        print('backing up data...')

        pool = BucketThreadPool(6, None, None, self.get_remote_s3_bucket)

        for root, dirnames, filenames in os.walk(self._data_path):
            for filename in filenames:
                file_path = os.path.join(root, filename)
                key_name = file_path[len(self._data_path):]
                remote_key_name = self.get_remote_key_name('data', key_name)
                pool.add_task(self.backup_data_file, *(file_path, remote_key_name))

        pool.wait_and_shutdown()

    def backup_data_file(self, file_path, remote_key_name, remote_bucket=None):
        stat = os.stat(file_path)
        fp = file(file_path)
        key = Key(remote_bucket, remote_key_name)
        key.metadata = {'uid': stat.st_uid, 'gid': stat.st_gid}
        self.set_contents_from_file(key, fp)
        key.close()
        fp.close()

    def restore_data(self):
        print('restoring data...')

        pool = BucketThreadPool(6, None, None, self.get_remote_s3_bucket)

        remote_bucket = self.get_remote_s3_bucket()
        prefix = self.get_base_directory() + '/data/'
        for key in remote_bucket.list(prefix=prefix):
            file_path = os.path.join(self._data_path, key.key[len(prefix):])
            dir_name = os.path.dirname(file_path)
            if not os.path.exists(dir_name):
                os.makedirs(dir_name)
            pool.add_task(self.restore_data_file, *(file_path, key.key))

        pool.wait_and_shutdown()

    def restore_data_file(self, file_path, remote_key_name, remote_bucket=None):
        fp = file(file_path, 'w')
        key = Key(remote_bucket, remote_key_name)
        self.get_contents_to_file(key, fp)
        try:
            uid = int(key.get_metadata('uid'))
            gid = int(key.get_metadata('gid'))
            os.chown(file_path, uid, gid)
        except:
            pass

        key.close()
        fp.close()

class ThreadPool:
    _workers = []

    def __init__(self, num_threads, **worker_args):
        self._tasks = Queue.Queue(num_threads)
        self._worker_args = worker_args

        for _ in range(num_threads):
            self.create_worker(self._tasks, self._worker_args)

    def create_worker(self, tasks, **worker_args):
        self._workers.append(ThreadPoolWorker(tasks, worker_args))

    def add_task(self, func, *args):
        self._tasks.put((func, args))

    def wait_completion(self):
        self._tasks.join()

    def shutdown(self):
        for worker in self._workers:
            worker.stop()

    def wait_and_shutdown(self):
        self.wait_completion()
        self.shutdown()

class BucketThreadPool(ThreadPool):
    _deis_bucket = None
    _remote_bucket = None

    def __init__(self, num_threads, deis_bucket_fn, deis_bucket_name, remote_bucket_fn, **worker_args):
        if deis_bucket_fn is not None:
            self._deis_bucket = deis_bucket_fn(deis_bucket_name)

        if remote_bucket_fn is not None:
            self._remote_bucket = remote_bucket_fn()

        ThreadPool.__init__(self, num_threads, **worker_args)

    def create_worker(self, tasks, deis_bucket_fn=None, deis_bucket_name=None, remote_bucket_fn=None, **worker_args):
        if self._deis_bucket is not None:
            worker_args['deis_bucket'] = self._deis_bucket
        if self._remote_bucket is not None:
            worker_args['remote_bucket'] = self._remote_bucket
        self._workers.append(ThreadPoolWorker(tasks, **worker_args))

class ThreadPoolWorker(threading.Thread):
    def __init__(self, tasks, **args):
        threading.Thread.__init__(self)
        self._stop = threading.Event()
        self._tasks = tasks
        self._args = args
        self.daemon = False
        self.start()

    def stop(self):
        self._stop.set()

    def stopped(self):
        return self._stop.isSet()

    def run(self):
        while not self.stopped():
            try:
                func, args = self._tasks.get_nowait()
                func(*args, **self._args)
                self._tasks.task_done()
            except Queue.Empty:
                time.sleep(1)
                pass
            except:
                print traceback.format_exc()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Backup and restore Deis data')
    parser.add_argument('--key', required=True, dest='aws_access_key_id', help='s3 key id')
    parser.add_argument('--secret', required=True, dest='aws_secret_access_key', help='s3 secret key')
    parser.add_argument('--bucket', required=True, dest='bucket_name', help='s3 backup bucket')
    parser.add_argument('--host', dest='host', default='s3.amazonaws.com', help='s3 host')
    parser.add_argument('--port', dest='port', default=443, type=int, help='s3 port')
    parser.add_argument('--insecure', dest='is_secure', action='store_false', help='s3 use ssl connection')
    parser.add_argument('--dry-run', dest='dry_run', action='store_true', help='dry run')
    parser.add_argument('--etcd-host', dest='etcd_host', default='127.0.0.1', help='etcd host')
    parser.add_argument('--etcd-port', dest='etcd_port', default=4001, type=bool, help='etcd port')
    parser.add_argument('--no-data', dest='no_data', action='store_true', help='don\'t include store data')

    subparsers = parser.add_subparsers(help='sub-command help')
    parser_backup = subparsers.add_parser('backup', help='backup help')
    parser_backup.set_defaults(cmd='backup')

    parser_restore = subparsers.add_parser('restore', help='restore help')
    parser_restore.add_argument('directory', help='directory on remote s3 to restore')
    parser_restore.set_defaults(cmd='restore')

    args = vars(parser.parse_args())
    cmd = args.pop('cmd')
    directory = args.pop('directory', None)
    object = DeisBackupRestore(**args)

    if cmd is 'backup':
        object.backup()
    elif cmd is 'restore':
        object.restore(directory)

redpajama_set_name: RedPajamaGithub


After all, a dating site is designed to allow people to meet each other so if you want to exchange email addresses or phone numbers, that's fine with us. If you're a single parent, having to juggle time with your children and making time to meet someone for a relationship can be difficult.The decision making and the communication is up to you.You don't need to answer lots questions - save these for when you meet face to face.Free dating sites like Flirthut can help make things a little easier for you by giving you an opportunity to meet someone online without having to pay for subscriptions or create complex accounts. And because we're simple, you'll have more time to search around and less time worrying about what information you've given.


Power Grid is the updated release of the Friedemann Friese crayon game Funkenschlag. The latest cooperative publishing effort from Friedemann Friese and Rio Grande Games, removes the crayon aspect from network building in the original edition while retaining the fluctuating commodities market like McMulti and an auction round intensity reminiscent of The Princes of Florence.
However, as plants are purchased, newer more efficient plants become available, so by merely purchasing you're potentially allowing others access to superior equipment.
Additionally, players must acquire the raw materials (coal, oil, garbage and uranium) needed to power said plants (except for the 'renewable' windfarm/ solar plants which require no fuel), making it a constant struggle to upgrade your plants for maximum efficiency while still retaining enough wealth to quickly expand your network to get the cheapest routes.


Native Instruments Traktor Scratch Duo features Traktor Duo DJ software, Audio 4 DJ USB Audio Interface and coded control Vinyls and CDs.
Native Instruments Traktor Scratch Duo is a powerful, easy-to-use system with two playback decks for DJs spinning digital tracks on vinyl and CD.
Native Instruments Traktor Scratch Duo features the Traktor Duo software, Audio 4 DJ interface and Control Vinyls and CDs.
For aspiring DJs who want to start spinning their digital tracks on vinyl and CD, TRAKTOR SCRATCH DUO is the complete solution that provides both the software and hardware to perfectly fuse the worlds of analog and digital DJing. TRAKTOR SCRATCH DUO comes with the powerful TRAKTOR PRO-based TRAKTOR DUO software, the professional AUDIO 4 DJ interface, ultra-precise control records and CDs plus many more valuable features to get you spinning in no time.
The included TRAKTOR DUO software features two state-of-the-art playback decks, an intuitive graphic interface with a Crate Flick cover art browser. Advanced looping capabilities, with multiple loop and cue points plus up to three chainable tempo sync'd effects per channel let you get deep inside the tracks you spin. TRAKTOR SCRATCH DUO combines unparalleled creative potential with ease of use and rock-solid dependability.
TRAKTOR SCRATCH DUO comes with AUDIO 4 DJ, a superior USB bus-powered audio interface built specifically for DJing. This low-latency 24-bit/96 kHz interface uses high-end Cirrus Logic® AD/DA converters for pristine audio quality – just like its multi award-winning big brother AUDIO 8 DJ. Four switchable inputs and four hi-gain (9.7 dBu) outputs let you connect to an external mixer and turntables or CD decks in seconds.
TRAKTOR SCRATCH DUO enables you to seamlessly fuse analog and digital DJing. The 2 kHz control signal of the included vinyl and CDs is twice the resolution of the competitors. This unmatched responsiveness means that everything from slow rubs to quick backspins and even motor-offs responds just like vinyl. Pressed with extreme care onto high-quality 120g discs, it feels like each digital file is cut into the wax.
TRAKTOR SCRATCH DUO comes with a dedicated Scratch Library. The included exclusive audio material offers instant usability and unique features for all turntablists. Over 700 MB of sounds recorded in 24 bit / 96 kHz audio quality are itching to be scratched and include many lead sounds for solo scratching as well as sound FX, endless tones, tunes for juggling, loops and more.


The institutional policy for the quality of UAlg is based on the sharing and commitment of the academic community with the mission and values defined in its Statutes and with the guidelines defined in its Strategic Plan, with the objective of continuous improvement of its activity. The Strategic Plan integrates objectives, strategic initiatives and respective indicators, established for each of the areas: Teaching, Research, Extension and Governance and was the object of an intense process of consultation and debate both internally and externally, with the participation of all stakeholders.
The pursuit of the objectives for quality is supervised through processes and procedures that allow monitoring and evaluation of the activities carried out, in order to ensure compliance with internal and external requirements, and simultaneously lead to the continuous improvement of the University's performance.
Institutional policy for the quality of the University of Algarve (UAlg) is closely associated with the mission and strategy of development of the institution. Therefore, the SIGQUAlg is based in essence on two documents, the Quality Manual (MQ) and the Strategic Plan, which are assisted by a third document, the Annual Plan of Activities.
The Quality Manual systematizes the information related to the quality policy and the organization of the SIGQUAlg, explaining the interconnection between the policy for quality and the mission and strategy of UAlg, the skills and relationships of government agencies under the SIGQUAlg, the procedures, regulations, norms, and other documents, as well as the forms of participation and involvement of all stakeholders in the process of continuous improvement of the activities developed in the framework of UAlg mission.
The quadrennial strategic plan establishes the guidelines for the development of UAlg and integrates for each aspect of its mission, goals, strategic initiatives and performance indicators.
The annual plan of activities integrates actions to achieve objectives and strategic initiatives set out in the strategic plan. For every action, the process of implementation, players and expected results are identified.
To ensure that the Quality Assurance processes are articulated with the strategic plan and the activity plans and respond adequately to the guidelines defined by the national and European quality assurance systems of higher education.
One student per Teaching Unit and per Department of Biomedical Sciences and Medicine, designated by his / her peers from the Pedagogical Council.
The decisions of the CCQ are set out in minutes, drawn up by the Quality Assessment Office, made available on the UAlg intranet.
To review the Quality Manual.
Coordinator of the Quality Assessment Office.
Quality Assurance Committee (CGQ) of the University of the Algarve meets ordinarily once per semester and extraordinarily whenever it is convened by decision of the coordinator.
The decisions of the CGQ are set out in minutes, drawn up by the GAQ, made available on UAlg's intranet.
To ensure the permanent updating of the indicators and of the information required by the SIGQUAlg.


Maintaining everything from the floors to the roof is part of what you have to do when you own a home.
If it's in your budget, then you can sometimes hire someone to provide the maintenance that the home needs.
There are a few tips that you can keep in mind so that you don't have to hire someone until there is something that needs to be fixed that you can't handle.
There are usually filters on most of the large appliances and units in your home. Check the filters on your HVAC unit, air conditioner, and furnace at least once a month.
You should also check the compartment under the refrigerator and any filters or trays in the freezer or the dishwasher.
If you keep everything clean and free of dust and debris, then the system will usually continue to operate properly for an extended time.
The plumbing system is one that often gives homeowners the most trouble. Examine the pipes underneath and inside the home to ensure that there are no leaks. Wrap your pipes in the winter to keep them from freezing in cold temperatures.
Keep the drains in the home clean by using products that eat away any debris that might be stuck in the lines.
If there are any pipes that you can't access or repair, then consider contacting a plumber who can offer assistance so that no further damage is done.
Even simple drain cleaning can sometimes turn into struggle, so don't be afraid to call for back-up.
Keeping the gutter system clean can also keep the roof in the best condition possible. When water backs up in the gutter system, it often means that water will begin to seep into these areas of the roof as well.
Clean your gutters at least once a month to remove any leaves, sticks or other items that could prevent water from flowing like it should.
You should also make sure that the spouts are not resting against the side of the house as they could get damaged in windy conditions by blowing and hitting the home.
Examine the windows and doors of the home to make sure there are no cracks in the glass and to see that there are no drafts around the edges.
When there are drafts around the windows and door frames, then they can impact the temperature of the home, which means that the heating or cooling unit will run more than it should.
Seal any air leaks that you find, or replace your windows with energy-efficient ones to save money on your utility bill.
Maintaining your home isn't hard if you take some time each month to inspect a few areas. Most of the maintenance can be done while you're performing other chores inside and outside the home, such as checking the gutters after mowing.
If you maintain your home, then it will be less expensive and less time consuming to repair it in the future.
Should You Invest in a Water Filtration System or a Water Softening System?


I am a retired goverment officer. Before divorcing approximately 2yrs ago I had been married for 35yrs and have 4 grown-up children. I am well educated, over weight but also big hearted and fair minded with a caring and responsible attitude.
Young man that is looking for that special person!
i'm honest and caring with good sense of humour.i am disabled from a accident at work that broke my spine so i have to use a wheelchair for ever.looking for some one who is caring an honest.
loving, responsible, dependable, honest, understanding,well travelled,life experenced,like quite life,private person,fit,healthy. children adults left home.Own house.
I consider myself to be honest,down to earth,reliable,romantic,caring.I am looking for that special lady to spend the rest of my life with.I would love also to start a family.
I am living alone and looking for an honest woman to share my life with. I live on the coast by the sea in a verry small village. Its very quiet here in Winter.
i like gardening walking animals i am a shy person intelligent a loving tender person,and i honour and respect a good close friend.