Standard Function implementations¶
Chainer provides basic Function
implementations in the
chainer.functions
package. Most of them are wrapped by plain Python
functions, which users should use.
Note
As of v1.5, the concept of parameterized functions are gone, and they are
replaced by corresponding Link
implementations. They are
still put in the functions
namespace for backward
compatibility, though it is strongly recommended to use them via the
chainer.links
package.
Activation functions¶
clipped_relu¶
crelu¶
elu¶
-
chainer.functions.
elu
(x, alpha=1.0)[source]¶ Exponential Linear Unit function.
This function is expressed as
\[\begin{split}f(x) = \left \{ \begin{array}{ll} x & {\rm if}~ x \ge 0 \\ \alpha (\exp(x) - 1) & {\rm if}~ x < 0, \end{array} \right.\end{split}\]where \(\alpha\) is a parameter. See: http://arxiv.org/abs/1511.07289
Parameters: Returns: Output variable.
Return type:
hard_sigmoid¶
leaky_relu¶
log_softmax¶
-
chainer.functions.
log_softmax
(x, use_cudnn=True)[source]¶ Channelwise log-softmax function.
This function computes its logarithm of softmax along the second axis.  For each index \(i\) of the input array \(f(i)\), it computes the logarithm of the probability \(\log p(x)\) defined as
\[p(i) = {\exp(f(i)) \over \sum_{i'_2} \exp(f(i'))},\]where \(i' = (i_1, i'_2, \dots, i_d)\).
\[p(x) = {\exp(f(x)) \over \sum_{x'} \exp(f(x'))}.\]This method is theoretically equivalent to
log(softmax(x))
but is more stable.Note
log(softmax(x))
may cause underflow whenx
is too small, becausesoftmax(x)
may returns0
.log_softmax
method is more stable.Parameters: Returns: Output variable.
Return type: See also
lstm¶
-
chainer.functions.
lstm
(c_prev, x)[source]¶ Long Short-Term Memory units as an activation function.
This function implements LSTM units with forget gates. Let the previous cell state \(c_{\text{prev}}\) and the incoming signal \(x\).
First, the incoming signal \(x\) is split into four arrays \(a, i, f, o\) of the same shapes along the second axis. It means that \(x\) ‘s second axis must have 4 times the length of \(c_{\text{prev}}\).
The split input signals are corresponding to:
- \(a\) : sources of cell input
- \(i\) : sources of input gate
- \(f\) : sources of forget gate
- \(o\) : sources of output gate
Second, it computes outputs as:
\[\begin{split}c &= \tanh(a) \text{sigmoid}(i) + c_{\text{prev}} \text{sigmoid}(f), \\ h &= \tanh(c) \text{sigmoid}(o).\end{split}\]These are returned as a tuple of two variables.
Parameters: Returns: Two
Variable
objectsc
andh
.c
is the updated cell state.h
indicates the outgoing signal.Return type: See the original paper proposing LSTM with forget gates: Long Short-Term Memory in Recurrent Neural Networks.
Example
Assuming
y
is the current input signal,c
is the previous cell state, andh
is the previous output signal from anlstm
function. Each ofy
,c
andh
hasn_units
channels. Most typical preparation ofx
is:>>> import chainer, chainer.functions as F >>> n_units = 100 >>> y = chainer.Variable(numpy.zeros((1, n_units), 'f')) >>> h = chainer.Variable(numpy.zeros((1, n_units), 'f')) >>> c = chainer.Variable(numpy.zeros((1, n_units), 'f')) >>> model = chainer.Chain(w=F.Linear(n_units, 4 * n_units), ... v=F.Linear(n_units, 4 * n_units),) >>> x = model.w(y) + model.v(h) >>> c, h = F.lstm(c, x)
It corresponds to calculate the input sources \(a, i, f, o\) from the current input
y
and the previous outputh
. Different parameters are used for different kind of input sources.
maxout¶
-
chainer.functions.
maxout
(x, pool_size, axis=1)[source]¶ Maxout activation function.
It accepts an input tensor
x
, reshapes theaxis
dimension (say the size beingM * pool_size
) into two dimensions(M, pool_size)
, and takes maximum along theaxis
dimension. The output of this function is same asx
except thataxis
dimension is transformed fromM * pool_size
toM
.Typically,
x
is the output of a linear layer or a convolution layer. The following is the example where we usemaxout()
in combination with a Linear link.>>> import numpy, chainer, chainer.links as L >>> in_size, out_size, pool_size = 100, 100, 100 >>> l = L.Linear(in_size, out_size * pool_size) >>> x = chainer.Variable(numpy.zeros((1, in_size), 'f')) # prepare data >>> x = l(x) >>> y = maxout(x, pool_size)
Parameters: x (Variable) – Input variable. Its first dimension is assumed to be the minibatch dimension. The other dimensions are treated as one concatenated dimension. Returns: Output variable. Return type: Variable See also
prelu¶
-
chainer.functions.
prelu
(x, W)[source]¶ Parametric ReLU function.
It accepts two arguments: an input
x
and a weight arrayW
and computes the output as \(PReLU(x) = \max(x, W*x)\), where \(*\) is an elementwise multiplication for each sample in the batch.When the PReLU function is combined with two-dimensional convolution, the elements of parameter \(a\) are typically shared across the same filter of different pixels. In order to support such usage, this function supports the shape of parameter array that indicates leading dimensions of input arrays except the batch dimension.
For example \(W\) has the shape of \((2, 3, 4)\), \(x\) must have the shape of \((B, 2, 3, 4, S1, ..., SN)\) where B is batchsize and the number of trailing S’s is arbitrary non-negative integer.
Parameters: Returns: Output variable
Return type: See also
relu¶
sigmoid¶
slstm¶
-
chainer.functions.
slstm
(c_prev1, c_prev2, x1, x2)[source]¶ S-LSTM units as an activation function.
This function implements S-LSTM unit. It is an extension of LSTM unit applied to tree structures. The function is applied to binary trees. Each node has two child nodes. It gets four arguments, previous cell states \(c_1\) and \(c_2\), and incoming signals \(x_1\) and \(x_2\).
First both input signals \(x_1\) and \(x_2\) are split into eight arrays \(a_1, i_1, f_1, o_1\), and \(a_2, i_2, f_2, o_2\). They have the same shape along the second axis. It means that \(x_1\) and \(x_2\) ‘s second axis must have 4 times the length of \(c_{1 \text{prev}}\) and \(c_{2 \text{prev}}\).
The split input signals are corresponding to:
- \(a_i\) : sources of cell input
- \(i_i\) : sources of input gate
- \(f_i\) : sources of forget gate
- \(o_i\) : sources of output gate
It computes outputs as:
\[\begin{split}c &= \tanh(a_1 + a_2) \sigma(i_1 + i_2) + c_{1 \text{prev}} \sigma(f_1) + c_{2 \text{prev}} \sigma(f_2), \\ h &= \tanh(c) \sigma(o_1 + o_2),\end{split}\]where \(\sigma\) is the elementwise sigmoid function. The function returns \(c\) and \(h\) as a tuple.
Parameters: - c_prev1 (Variable) – Variable that holds the previous cell state of the first child node. The cell state should be a zero array or the output of the previous call of LSTM.
- c_prev2 (Variable) – Variable that holds the previous cell state of the second child node.
- x1 (Variable) – Variable that holds the incoming signal from the first child node. It must have the second dimension four times of that of the cell state,
- x2 (Variable) – Variable that holds the incoming signal from the second child node.
Returns: Two
Variable
objectsc
andh
.c
is the cell state.h
indicates the outgoing signal.Return type: See detail in paper: Long Short-Term Memory Over Tree Structures.
softmax¶
-
chainer.functions.
softmax
(x, use_cudnn=True)[source]¶ Channelwise softmax function.
This function computes its softmax along the second axis.  For each index \(x\) of the input array \(f(x)\), it computes the probability \(p(x)\) defined as \(p(x) = {\exp(f(x)) \over \sum_{x_2} \exp(f(x))}\).
Parameters: Returns: Output variable.
Return type:
Array manipulations¶
broadcast¶
broadcast_to¶
cast¶
concat¶
copy¶
-
chainer.functions.
copy
(x, dst)[source]¶ Copies the input variable onto the specified device.
This function copies the array of input variable onto the device specified by
dst
if the original array is on GPU, and otherwise just copies the array within host memory.Parameters: - x (Variable) – Variable to be copied.
- dst – Target device specifier.
Returns: Output variable.
Return type:
dstack¶
expand_dims¶
flatten¶
fliplr¶
flipud¶
get_item¶
hstack¶
permutate¶
reshape¶
rollaxis¶
select_item¶
separate¶
split_axis¶
-
chainer.functions.
split_axis
(x, indices_or_sections, axis, force_tuple=False)[source]¶ Splits given variables along an axis.
Parameters: - x (tuple of Variables) – Variables to be split.
- indices_or_sections (int or 1-D array) – If this argument is an integer, N, the array will be divided into N equal arrays along axis. If it is a 1-D array of sorted integers, it indicates the positions where the array is split.
- axis (int) – Axis that the input array is split along.
- force_tuple (bool) – If
True
, this method returns a tuple even when the number of outputs is one.
Returns: Tuple of
Variable
objects if the number of outputs is more than 1 orVariable
otherwise. Whenforce_tuple
isTrue
, returned value is always a tuple regardless of the number of outputs.Return type: tuple or Variable
Note
This function raises
ValueError
if at least one of the outputs is split to zero-size (i.e.axis
-th value of its shape is zero).
squeeze¶
stack¶
swapaxes¶
tile¶
transpose¶
-
chainer.functions.
transpose
(x, axes=None)[source]¶ Permute the dimensions of an input variable without copy.
Parameters: - x (Variable) – Input variable.
- axes (tuple of ints) – By default, reverse the dimensions, otherwise permute the axes according to the values given.
Returns: Variable whose axes are permuted.
Return type:
transpose_sequence¶
vstack¶
Neural network connections¶
bilinear¶
-
chainer.functions.
bilinear
(e1, e2, W, V1=None, V2=None, b=None)[source]¶ Applies a bilinear function based on given parameters.
This is a building block of Neural Tensor Network (see the reference paper below). It takes two input variables and one or four parameters, and outputs one variable.
To be precise, denote six input arrays mathematically by \(e^1\in \mathbb{R}^{I\cdot J}\), \(e^2\in \mathbb{R}^{I\cdot K}\), \(W\in \mathbb{R}^{J \cdot K \cdot L}\), \(V^1\in \mathbb{R}^{J \cdot L}\), \(V^2\in \mathbb{R}^{K \cdot L}\), and \(b\in \mathbb{R}^{L}\), where \(I\) is mini-batch size. In this document, we call \(V^1\), \(V^2\), and \(b\) linear parameters.
The output of forward propagation is calculated as
\[y_{il} = \sum_{jk} e^1_{ij} e^2_{ik} W_{jkl} + \ \sum_{j} e^1_{ij} V^1_{jl} + \sum_{k} e^2_{ik} V^2_{kl} + b_{l}.\]Note that V1, V2, b are optional. If these are not given, then this function omits the last three terms in the above equation.
Note
This function accepts an input variable
e1
ore2
of a non-matrix array. In this case, the leading dimension is treated as the batch dimension, and the other dimensions are reduced to one dimension.Note
In the original paper, \(J\) and \(K\) must be equal and the author denotes \([V^1 V^2]\) (concatenation of matrices) by \(V\).
Parameters: Returns: Output variable.
Return type: - See:
- Reasoning With Neural Tensor Networks for Knowledge Base Completion [Socher+, NIPS2013].
convolution_2d¶
-
chainer.functions.
convolution_2d
(x, W, b=None, stride=1, pad=0, use_cudnn=True)[source]¶ Two-dimensional convolution function.
This is an implementation of two-dimensional convolution in ConvNets. It takes three variables: the input image
x
, the filter weightW
, and the bias vectorb
.Notation: here is a notation for dimensionalities.
- \(n\) is the batch size.
- \(c_I\) and \(c_O\) are the number of the input and output, respectively.
- \(h\) and \(w\) are the height and width of the input image, respectively.
- \(k_H\) and \(k_W\) are the height and width of the filters, respectively.
Parameters: - x (Variable) – Input variable of shape \((n, c_I, h, w)\).
- W (Variable) – Weight variable of shape \((c_O, c_I, k_H, k_W)\).
- b (Variable) – Bias variable of length \(c_O\) (optional).
- stride (int or pair of ints) – Stride of filter applications.
stride=s
andstride=(s, s)
are equivalent. - pad (int or pair of ints) – Spatial padding width for input arrays.
pad=p
andpad=(p, p)
are equivalent. - use_cudnn (bool) – If
True
, then this function uses cuDNN if available.
Returns: Output variable.
Return type: The two-dimensional convolution function is defined as follows. Then the
Convolution2D
function computes correlations between filters and patches of size \((k_H, k_W)\) inx
. Note that correlation here is equivalent to the inner product between expanded vectors. Patches are extracted at positions shifted by multiples ofstride
from the first position-pad
for each spatial axis. The right-most (or bottom-most) patches do not run over the padded spatial size.Let \((s_Y, s_X)\) be the stride of filter application, and \((p_H, p_W)\) the spatial padding size. Then, the output size \((h_O, w_O)\) is determined by the following equations:
\[\begin{split}h_O &= (h + 2p_H - k_H) / s_Y + 1,\\ w_O &= (w + 2p_W - k_W) / s_X + 1.\end{split}\]If the bias vector is given, then it is added to all spatial locations of the output of convolution.
See also
Convolution2D
convolution_nd¶
deconvolution_2d¶
-
chainer.functions.
deconvolution_2d
(x, W, b=None, stride=1, pad=0, outsize=None, use_cudnn=True)[source]¶ Two dimensional deconvolution function.
This is an implementation of two-dimensional deconvolution. It takes three variables: input image
x
, the filter weightW
, and the bias vectorb
.Parameters: - x (Variable) – Input variable of shape \((n, c_I, h, w)\).
- W (Variable) – Weight variable of shape \((c_I, c_O, k_H, k_W)\).
- b (Variable) – Bias variable of length \(c_O\) (optional).
- stride (int or pair of ints) – Stride of filter applications.
stride=s
andstride=(s, s)
are equivalent. - pad (int or pair of ints) – Spatial padding width for input arrays.
pad=p
andpad=(p, p)
are equivalent. - outsize (tuple) – Expected output size of deconvolutional operation.
It should be pair of height and width \((out_H, out_W)\).
Default value is
None
and the outsize is estimated by input size, stride and pad. - use_cudnn (bool) – If
True
, then this function uses cuDNN if available.
The filter weight has four dimensions \((c_I, c_O, k_H, k_W)\) which indicate the number of the number of input channels, output channels, height and width of the kernels, respectively.
The bias vector is of size \(c_O\).
Let \(X\) be the input tensor of dimensions \((n, c_I, h, w)\), \((s_Y, s_X)\) the stride of filter application, and \((p_H, p_W)\) the spatial padding size. Then, the output size \((h_O, w_O)\) is determined by the following equations:
\[\begin{split}h_O &= s_Y (h - 1) + k_H - 2p_H,\\ w_O &= s_X (w - 1) + k_W - 2p_W.\end{split}\]
deconvolution_nd¶
dilated_convolution_2d¶
embed_id¶
-
chainer.functions.
embed_id
(x, W, ignore_label=None)[source]¶ Efficient linear function for one-hot input.
This function implements so called word embedding. It takes two arguments: a set of IDs (words)
x
in \(B\) dimensional integer vector, and a set of all ID (word) embeddingsW
in \(V \times d\) float32 matrix. It outputs \(B \times d\) matrix whosei
-th column is thex[i]
-th column ofW
.This function is only differentiable on the input
W
.Parameters: Returns: Output variable.
Return type: See also
EmbedID
linear¶
n_step_lstm¶
Evaluation functions¶
accuracy¶
binary_accuracy¶
classification_summary¶
r2_score¶
Loss functions¶
bernoulli_nll¶
-
chainer.functions.
bernoulli_nll
(x, y)[source]¶ Computes the negative log-likelihood of a Bernoulli distribution.
This function calculates the negative log-likelihood of a Bernoulli distribution.
\[-B(x; p) = -\sum_i {x_i \log(p_i) + (1 - x_i)\log(1 - p_i)},\]where \(p = \sigma(y)\), and \(\sigma(\cdot)\) is a sigmoid function.
Note
As this function uses a sigmoid function, you can pass a result of fully-connected layer (that means
Linear
) to this function directly.Parameters: Returns: A variable representing negative log-likelihood.
Return type:
black_out¶
connectionist_temporal_classification¶
-
chainer.functions.
connectionist_temporal_classification
(x, t, blank_symbol, input_length=None, label_length=None)[source]¶ Connectionist Temporal Classification loss function.
Connectionist Temporal Classification(CTC) [Graves2006] is a loss function of sequence labeling where the alignment between the inputs and target is unknown. See also [Graves2012]
Parameters: - x (sequence of Variable) – RNN output at each time.
x
must be a list ofVariable
s. Each element ofx
,x[i]
is aVariable
representing output of RNN at timei
. - t (Variable) – Expected label sequence.
- blank_symbol (int) – Index of blank_symbol. This value must be non-negative.
- input_length (Variable) – Length of valid sequence for each of mini batch x (optional). If input_length is skipped, It regards that all of x is valid input.
- label_length (Variable) – Length of valid sequence for each of mini batch t (optional). If label_length is skipped, It regards that all of t is valid input.
Returns: A variable holding a scalar value of the CTC loss.
Return type: Note
You need to input
x
without applying to activation functions(e.g. softmax function), because this function applies softmax functions tox
before calculating CTC loss to avoid numerical limitations. You also need to apply softmax function to forwarded values before you decode it.Note
This function is differentiable only by
x
.Note
This function supports (batch, sequence, 1-dimensional input)-data.
[Graves2006] Alex Graves, Santiago Fernandez, Faustino Gomez, Jurgen Schmidhuber, Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks [Graves2012] Alex Graves, Supervised Sequence Labelling with Recurrent Neural Networks - x (sequence of Variable) – RNN output at each time.
contrastive¶
-
chainer.functions.
contrastive
(x0, x1, y, margin=1)[source]¶ Computes contrastive loss.
It takes a pair of variables and a label as inputs. The label is 1 when those two input variables are similar, or 0 when they are dissimilar. Let \(N\) and \(K\) denote mini-batchsize and the dimension of input variables, respectively. The shape of both input variables should be
(N, K)
.\[L = \frac{1}{2N} \left( \sum_{n=1}^N y_n d_n^2 + (1 - y_n) \max ({\rm margin} - d_n, 0)^2 \right)\]where \(d_n = \| {\bf x_0}_n - {\bf x_1}_n \|_2\). \(N\) denotes the mini-batch size. Input variables, x0 and x1, have \(N\) vectors, and each vector is K-dimensional. Therefore, \({\bf x_0}_n\) and \({\bf x_1}_n\) are \(n\)-th K-dimensional vectors of x0 and x1.
Parameters: - x0 (Variable) – The first input variable. The shape should be (N, K), where N denotes the minibatch size, and K denotes the dimension of x0.
- x1 (Variable) – The second input variable. The shape should be the same as x0.
- y (Variable) – Labels. All values should be 0 or 1. The shape
should be
(N,)
, where N denotes the minibatch size. - margin (float) – A parameter for contrastive loss. It should be positive value.
Returns: A variable holding a scalar that is the loss value calculated by the above equation.
Return type: Note
This cost can be used to train siamese networks. See Learning a Similarity Metric Discriminatively, with Application to Face Verification <http://yann.lecun.com/exdb/publis/pdf/chopra-05.pdf> for details.
crf1d¶
cross_covariance¶
-
chainer.functions.
cross_covariance
(y, z)[source]¶ Computes the sum-squared cross-covariance penalty between
y
andz
Parameters: Returns: A variable holding a scalar of the cross covariance loss.
Return type: Note
This cost can be used to disentangle variables. See http://arxiv.org/abs/1412.6583v3 for details.
gaussian_kl_divergence¶
-
chainer.functions.
gaussian_kl_divergence
(mean, ln_var)[source]¶ Computes the KL-divergence of Gaussian variables from the standard one.
Given two variable
mean
representing \(\mu\) andln_var
representing \(\log(\sigma^2)\), this function returns a variable representing the KL-divergence between the given multi-dimensional Gaussian \(N(\mu, S)\) and the standard Gaussian \(N(0, I)\)\[D_{\mathbf{KL}}(N(\mu, S) \| N(0, I)),\]where \(S\) is a diagonal matrix such that \(S_{ii} = \sigma_i^2\) and \(I\) is an identity matrix.
Parameters: Returns: A variable representing KL-divergence between given gaussian distribution and the standard gaussian.
Return type:
gaussian_nll¶
-
chainer.functions.
gaussian_nll
(x, mean, ln_var)[source]¶ Computes the negative log-likelihood of a Gaussian distribution.
Given two variable
mean
representing \(\mu\) andln_var
representing \(\log(\sigma^2)\), this function returns the negative log-likelihood of \(x\) on a Gaussian distribution \(N(\mu, S)\),\[-\log N(x; \mu, \sigma^2) = \log\left(\sqrt{(2\pi)^D |S|}\right) + \frac{1}{2}(x - \mu)^\top S^{-1}(x - \mu),\]where \(D\) is a dimension of \(x\) and \(S\) is a diagonal matrix where \(S_{ii} = \sigma_i^2\).
Parameters: Returns: A variable representing the negative log-likelihood.
Return type:
hinge¶
-
chainer.functions.
hinge
(x, t, norm='L1')[source]¶ Computes the hinge loss for a one-of-many classification task.
\[L = \frac{1}{N} \sum_{n=1}^N \sum_{k=1}^K \left[ \max(0, 1 - \delta\{l_n = k\} t_{nk}) \right]^p\]where \(N\) denotes the batchsize, \(K\) is the number of classes of interest,
\[\begin{split}\delta \{ {\rm condition} \} = \left \{ \begin{array}{cc} 1 & {\rm if~condition} \\ -1 & {\rm otherwise,} \end{array} \right.\end{split}\]and
\[\begin{split}p = \left \{ \begin{array}{cc} 1 & {\rm if~norm} = {\rm 'L1'} \\ 2 & {\rm if~norm} = {\rm 'L2'.} \end{array} \right.\end{split}\]Parameters: Returns: A variable object holding a scalar array of the hinge loss \(L\).
Return type:
huber_loss¶
-
chainer.functions.
huber_loss
(x, t, delta)[source]¶ Loss function which is less sensitive to outliers in data than MSE.
\[a = x - t\]and
\[\begin{split}L_{\delta}(a) = \left \{ \begin{array}{cc} \frac{1}{2} a^2 & {\rm if~|a| \leq \delta} \\ \delta (|a| - \frac{1}{2} \delta) & {\rm otherwise,} \end{array} \right.\end{split}\]Parameters: Returns: A variable object holding a scalar array of the huber loss \(L_{\delta}\).
Return type: - See:
- Huber loss - Wikipedia.
mean_absolute_error¶
mean_squared_error¶
negative_sampling¶
-
chainer.functions.
negative_sampling
(x, t, W, sampler, sample_size)[source]¶ Negative sampling loss function.
In natural language processing, especially language modeling, the number of vocabulary is very large. Therefore, you need to spend a lot of time to calculate the gradient of the embedding matrix.
Instead, in negative sampling trick, you only need to calculate the gradient for a few sampled negative examples.
The objective function is below:
\[f(x, p) = \log \sigma(x^\top w_p) + \ k E_{i \sim P(i)}[\log \sigma(- x^\top w_i)],\]where \(\sigma(\cdot)\) is a sigmoid function, \(w_i\) is the weight vector for the word \(i\), and \(p\) is a positive example. It is approximated with \(k\) examples \(N\) sampled from probability \(P(i)\), like this:
\[f(x, p) \approx \log \sigma(x^\top w_p) + \ \sum_{n \in N} \log \sigma(-x^\top w_n).\]Each sample of \(N\) is drawn from the word distribution \(P(w)\). This is calculated as \(P(w) = \frac{1}{Z} c(w)^\alpha\), where \(c(w)\) is the unigram count of the word \(w\), \(\alpha\) is a hyper-parameter, and \(Z\) is the normalization constant.
Parameters: - x (Variable) – Batch of input vectors.
- t (Variable) – Vector of ground truth labels.
- W (Variable) – Weight matrix.
- sampler (FunctionType) – Sampling function. It takes a shape and
returns an integer array of the shape. Each element of this array
is a sample from the word distribution.
A
WalkerAlias
object built with the power distribution of word frequency is recommended. - sample_size (int) – Number of samples.
See: Distributed Representations of Words and Phrases and their Compositionality
See also
sigmoid_cross_entropy¶
-
chainer.functions.
sigmoid_cross_entropy
(x, t, use_cudnn=True, normalize=True)[source]¶ Computes cross entropy loss for sigmoid activations.
Parameters: - x (Variable) – A variable object holding a matrix whose (i, j)-th element indicates the unnormalized log probability of the j-th unit at the i-th example.
- t (Variable) – Variable holding an int32 vector of ground truth labels.
If
t[i] == -1
, correspondingx[i]
is ignored. Loss is zero if all ground truth labels are-1
. - normalize (bool) – Variable holding a boolean value which determines the normalization constant. If true, this function normalizes the cross entropy loss across all instances. If else, it only normalizes along a batch size.
Returns: A variable object holding a scalar array of the cross entropy loss.
Return type: Note
This function is differentiable only by
x
.
softmax_cross_entropy¶
-
chainer.functions.
softmax_cross_entropy
(x, t, use_cudnn=True, normalize=True, cache_score=True)[source]¶ Computes cross entropy loss for pre-softmax activations.
Parameters: - x (Variable) – Variable holding a multidimensional array whose element indicates unnormalized log probability: the first axis of the variable represents the number of samples, and the second axis represents the number of classes. While this function computes a usual softmax cross entropy if the number of dimensions is equal to 2, it computes a cross entropy of the replicated softmax if the number of dimensions is greater than 2.
- t (Variable) – Variable holding an int32 vector of ground truth labels.
If
t[i] == -1
, correspondingx[i]
is ignored. - normalize (Variable) – Variable holding a boolean value which determines the normalization constant. If true, this function normalizes the cross entropy loss across all instances. If else, it only normalizes along a batch size.
- cache_score (bool) – When it is
True
, the function stores result of forward computation to use it on backward computation. It reduces computational cost though consumes more memories.
Returns: A variable holding a scalar array of the cross entropy loss.
Return type: Note
This function is differentiable only by
x
.
triplet¶
Mathematical functions¶
arccos¶
arcsin¶
arctan¶
argmax¶
argmin¶
batch_inv¶
-
chainer.functions.
batch_inv
(a)[source]¶ Computes the inverse of a batch of square matrices.
Parameters: a (Variable) – Input array to compute the determinant for. Shape of the array should be (m, n, n)
where m is the number of matrices in the batch, andn
is the dimensionality of a square matrix.Returns: Inverse of every matrix in the batch of matrices. Return type: Variable
batch_l2_norm_squared¶
-
chainer.functions.
batch_l2_norm_squared
(x)[source]¶ L2 norm (a.k.a. Euclidean norm) squared.
This function implements the square of L2 norm on a vector. No reduction along batch axis is done.
Parameters: x (Variable) – Input variable. The first dimension is assumed to be the minibatch dimension. If x has more than two dimensions all but the first dimension are flattened to one dimension. Returns: Two dimensional output variable. Return type: Variable
batch_matmul¶
-
chainer.functions.
batch_matmul
(a, b, transa=False, transb=False)[source]¶ Computes the batch matrix multiplications of two sets of arrays.
Parameters: - a (Variable) – The left operand of the batch matrix multiplications.
A 2-D array of shape
(B, N)
is considered as B \(N \times 1\) matrices. A 3-D array of shape(B, M, N)
is considered as B \(M \times N\) matrices. - b (Variable) – The right operand of the batch matrix multiplications.
Its array is treated as matrices in the same way as
a
‘s array. - transa (bool) – If
True
, transpose each matrix in a. - transb (bool) – If
True
, transpose each matrix in b.
Returns: The result of the batch matrix multiplications as a 3-D array.
Return type: - a (Variable) – The left operand of the batch matrix multiplications.
A 2-D array of shape
bias¶
ceil¶
clip¶
cosh¶
floor¶
inv¶
linear_interpolate¶
log10¶
log1p¶
log2¶
logsumexp¶
matmul¶
-
chainer.functions.
matmul
(a, b, transa=False, transb=False)[source]¶ Computes the matrix multiplication of two arrays.
Parameters: - a (Variable) – The left operand of the matrix multiplication.
A 1-D array of shape
(N,)
is considered as an \(N \times 1\) matrix. A 2-D array of shape(M, N)
is considered as an \(M \times N\) matrix. - b (Variable) – The right operand of the matrix multiplication.
Its array is treated as a matrix in the same way as
a
‘s array. - transa (bool) – If
True
, transpose a. - transb (bool) – If
True
, transpose b.
Returns: The result of the matrix multiplication as a 2-D array.
Return type: - a (Variable) – The left operand of the matrix multiplication.
A 1-D array of shape
max¶
-
chainer.functions.
max
(x, axis=None, keepdims=False)[source]¶ Maximum of array elements over a given axis.
Parameters: - x (Variable) – Array to be maximized.
- axis (None, int, or tuple of int) – Axis over which a max is performed. The default (axis = None) is perform a max over all the dimensions of the input array.
Returns: Output variable.
Return type:
maximum¶
min¶
-
chainer.functions.
min
(x, axis=None, keepdims=False)[source]¶ Minimum of array elements over a given axis.
Parameters: - x (Variable) – Array to be minimized.
- axis (None, int, or tuple of int) – Axis over which a min is performed. The default (axis = None) is perform a min over all the dimensions of the input array.
Returns: Output variable.
Return type:
minimum¶
rsqrt¶
scale¶
sinh¶
sqrt¶
square¶
squared_difference¶
sum¶
-
chainer.functions.
sum
(x, axis=None)[source]¶ Sum of array elements over a given axis.
Parameters: - x (Variable) – Elements to sum.
- axis (None, int, or tuple of int) – Axis which a sum is performed. The default (axis = None) is perform a sum over all the dimensions of the input array.
Returns: Output variable.
Return type:
tan¶
Noise injections¶
dropout¶
-
chainer.functions.
dropout
(x, ratio=0.5, train=True)[source]¶ Drops elements of input variable randomly.
This function drops input elements randomly with probability
ratio
and scales the remaining elements by factor1 / (1 - ratio)
. In testing mode, it does nothing and just returnsx
.Parameters: Returns: Output variable.
Return type: See the paper by G. Hinton: Improving neural networks by preventing co-adaptation of feature detectors.
Normalization functions¶
batch_normalization¶
-
chainer.functions.
batch_normalization
(x, gamma, beta, eps=1e-05)[source]¶ Batch normalization function.
It takes the input variable
x
and two parameter variablesgamma
andbeta
. The input must have the batch size and the features (or channels) as the first two dimensions of its shape. The input can have more than two dimensions, where the remained dimensions are considered as spatial dimensions, which are considered as a part of the batch size.Parameters: See: Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift
See also
links.BatchNormalization
fixed_batch_normalization¶
-
chainer.functions.
fixed_batch_normalization
(x, gamma, beta, mean, var, eps=1e-05)[source]¶ Batch normalization function with fixed statistics.
This is a variant of batch normalization, where the mean and variance statistics are given by the caller as variables. This is used on testing mode of the batch normalization layer, where batch statistics cannot be used for prediction consistency.
Parameters: - x (Variable) – The input variable.
- gamma (Variable) – The scaling parameter of normalized data.
- beta (Variable) – The shifting parameter of scaled normalized data.
- mean (Variable) – The shifting parameter of input.
- var (Variable) – The square of scaling parameter of input.
- eps (float) – Epsilon value for numerical stability.
See also
functions.batch_normalization()
,links.BatchNormalization
local_response_normalization¶
-
chainer.functions.
local_response_normalization
(x, n=5, k=2, alpha=0.0001, beta=0.75)[source]¶ Local response normalization across neighboring channels.
This function implements normalization across channels. Let \(x\) an input image with \(N\) channels. Then, this function computes an output image \(y\) by following formula:
\[y_i = {x_i \over \left( k + \ \alpha \sum_{j=\max{1, i - n/2}}^{\min{N, i + n/2}} \ x_j^2 \right)^\beta}.\]Parameters: Returns: Output variable.
Return type: See: Section 3.3 of ImageNet Classification with Deep Convolutional Neural Networks
normalize¶
Spatial pooling¶
average_pooling_2d¶
-
chainer.functions.
average_pooling_2d
(x, ksize, stride=None, pad=0, use_cudnn=True)[source]¶ Spatial average pooling function.
This function acts similarly to
Convolution2D
, but it computes the average of input spatial patch for each channel without any parameter instead of computing the inner products.Parameters: - x (Variable) – Input variable.
- ksize (int or pair of ints) – Size of pooling window.
ksize=k
andksize=(k, k)
are equivalent. - stride (int or pair of ints or None) – Stride of pooling applications.
stride=s
andstride=(s, s)
are equivalent. If None is specified, then it uses same stride as the pooling window size. - pad (int or pair of ints) – Spatial padding width for the input array.
pad=p
andpad=(p, p)
are equivalent. - use_cudnn (bool) – If
True
and cuDNN is enabled, then this function uses cuDNN as the core implementation.
Returns: Output variable.
Return type: Note
This function currently does not support
cover_all
mode asmax_pooling_2d()
. Average pooling runs in non-cover-all mode.
average_pooling_nd¶
max_pooling_2d¶
-
chainer.functions.
max_pooling_2d
(x, ksize, stride=None, pad=0, cover_all=True, use_cudnn=True)[source]¶ Spatial max pooling function.
This function acts similarly to
Convolution2D
, but it computes the maximum of input spatial patch for each channel without any parameter instead of computing the inner products.Parameters: - x (Variable) – Input variable.
- ksize (int or pair of ints) – Size of pooling window.
ksize=k
andksize=(k, k)
are equivalent. - stride (int or pair of ints or None) – Stride of pooling applications.
stride=s
andstride=(s, s)
are equivalent. IfNone
is specified, then it uses same stride as the pooling window size. - pad (int or pair of ints) – Spatial padding width for the input array.
pad=p
andpad=(p, p)
are equivalent. - cover_all (bool) – If
True
, all spatial locations are pooled into some output pixels. It may make the output size larger. - use_cudnn (bool) – If
True
and cuDNN is enabled, then this function uses cuDNN as the core implementation.
Returns: Output variable.
Return type:
max_pooling_nd¶
roi_pooling_2d¶
spatial_pyramid_pooling_2d¶
-
chainer.functions.
spatial_pyramid_pooling_2d
(x, pyramid_height, pooling_class, use_cudnn=True)[source]¶ Spatial pyramid pooling function.
It outputs a fixed-length vector regardless of input feature map size.
It performs pooling operation to the input 4D-array
x
with different kernel sizes and padding sizes, and then flattens all dimensions except first dimension of all pooling results, and finally concatenates them along second dimension.At \(i\)-th pyramid level, the kernel size \((k_h^{(i)}, k_w^{(i)})\) and padding size \((p_h^{(i)}, p_w^{(i)})\) of pooling operation are calculated as below:
\[\begin{split}k_h^{(i)} &= \lceil b_h / 2^i \rceil, \\ k_w^{(i)} &= \lceil b_w / 2^i \rceil, \\ p_h^{(i)} &= (2^i k_h^{(i)} - b_h) / 2, \\ p_w^{(i)} &= (2^i k_w^{(i)} - b_w) / 2,\end{split}\]where \(\lceil \cdot \rceil\) denotes the ceiling function, and \(b_h, b_w\) are height and width of input variable
x
, respectively. Note that index of pyramid level \(i\) is zero-based.See detail in paper: Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition.
Parameters: - x (Variable) – Input variable. The shape of
x
should be(batchsize, # of channels, height, width)
. - pyramid_height (int) – the number of pyramid levels
- pooling_class (MaxPooling2D or AveragePooling2D) – Only MaxPooling2D class can be available for now.
- use_cudnn (bool) – If
True
and cuDNN is enabled, then this function uses cuDNN as the core implementation.
Returns: Output variable. The shape of the output variable will be \((batchsize, c \sum_{h=0}^{H-1} 2^{2h}, 1, 1)\), where \(c\) is the number of channels of input variable
x
and \(H\) is the number of pyramid levels.Return type: Note
This function uses some pooling classes as components to perform spatial pyramid pooling. Now it supports only
MaxPooling2D
as elemental pooling operator so far.- x (Variable) – Input variable. The shape of
unpooling_2d¶
-
chainer.functions.
unpooling_2d
(x, ksize, stride=None, pad=0, outsize=None, cover_all=True)[source]¶ Inverse operation of pooling for 2d array.
This function acts similarly to
Deconvolution2D
, but it spreads input 2d array’s value without any parameter instead of computing the inner products.Parameters: - x (Variable) – Input variable.
- ksize (int or pair of ints) – Size of pooling window.
ksize=k
andksize=(k, k)
are equivalent. - stride (int, pair of ints or None) – Stride of pooling applications.
stride=s
andstride=(s, s)
are equivalent. IfNone
is specified, then it uses same stride as the pooling window size. - pad (int or pair of ints) – Spatial padding width for the input array.
pad=p
andpad=(p, p)
are equivalent. - outsize (None or pair of ints) – Expected output size (height, width)
of array after the operation. If
None
, the size (height or width) is estimated from the size of input array in first batch withget_deconv_outsize()
. If outsize is notNone
, the result of outsize applied toget_conv_outsize()
must be equal to the shape of the 2d array in the input batchx
. - cover_all (bool) – If
True
, all spatial locations are pooled into some output pixels, and the output size is larger than that when cover_all isFalse
.
Returns: Output variable.
Return type:


Re-ordering Feedback Categories
How to re-order categories on the Feedback module. Feedback module categories are listed in the order in which they are created.
- Select Edit > Edit Category/Subject Lists from the module actions menu. This opens the Edit Lists page.
- At List Type, select Categories.
- Click the Up or Down button beside a category to move it up or down one position in the list and then repeat as required.
- Repeat Step 3 to re-order additional categories.
- Click the Return to Module button when you are finished.


My Team
Name
manager
Work
Email
office #
Name
intern
Work
Email
school
Name
engineer
Work
Email
github


Actions, resources, and condition keys for AWS DataSync
AWS DataSync (service prefix:
datasync
) provides the following service-specific resources, actions, and condition context keys for use in IAM permission policies.
References:
-
Learn how to configure this service .
-
View a list of the API operations available for this service .
-
Learn how to secure this service and its resources by using IAM permission policies.
Topics
Actions defined by AWS DataSync
You can specify the following actions in the
Action
element of an IAM policy statement. Use policies to grant permissions to perform an operation in AWS. When you use an action in a policy, you usually allow or deny access to the API operation or CLI command with the same name. However, in some cases, a single action controls access to more than one operation. Alternatively, some operations require several different actions.
The
Resource types
column indicates whether each action supports resource-level permissions. If there is no value for this column, you must specify all resources ("*") in the
Resource
element of your policy statement. If the column includes a resource type, then you can specify an ARN of that type in a statement with that action. Required resources are indicated in the table with an asterisk (*). If you specify a resource-level permission ARN in a statement using this action, then it must be of this type. Some actions support multiple resource types. If the resource type is optional (not indicated as required), then you can choose to use one but not the other.
For details about the columns in the following table, see Actions table .
| Actions | Description | Access level | Resource types (*required) | Condition keys | Dependent actions |
|---|---|---|---|---|---|
| CancelTaskExecution | Grants permission to cancel execution of a sync task | Write | |||
| CreateAgent | Grants permission to activate an agent that you have deployed on your host | Write | |||
| CreateLocationEfs | Grants permission to create an endpoint for an Amazon EFS file system | Write | |||
| CreateLocationFsxLustre | Grants permission to create an endpoint for an Amazon Fsx Lustre | Write | |||
| CreateLocationFsxOpenZfs | Grants permission to create an endpoint for Amazon FSx for OpenZFS | Write | |||
| CreateLocationFsxWindows | Grants permission to create an endpoint for an Amazon FSx Windows File Server file system | Write | |||
| CreateLocationHdfs | Grants permission to create an endpoint for an Amazon Hdfs | Write | |||
| CreateLocationNfs | Grants permission to create an endpoint for a NFS file system | Write | |||
| CreateLocationObjectStorage | Grants permission to create an endpoint for a self-managed object storage bucket | Write | |||
| CreateLocationS3 | Grants permission to create an endpoint for an Amazon S3 bucket | Write | |||
| CreateLocationSmb | Grants permission to create an endpoint for an SMB file system | Write | |||
| CreateTask | Grants permission to create a sync task | Write | |||
| DeleteAgent | Grants permission to delete an agent | Write | |||
| DeleteLocation | Grants permission to delete a location used by AWS DataSync | Write | |||
| DeleteTask | Grants permission to delete a sync task | Write | |||
| DescribeAgent | Grants permission to view metadata such as name, network interfaces, and the status (that is, whether the agent is running or not) about a sync agent | Read | |||
| DescribeLocationEfs | Grants permission to view metadata, such as the path information about an Amazon EFS sync location | Read | |||
| DescribeLocationFsxLustre | Grants permission to view metadata, such as the path information about an Amazon FSx Lustre sync location | Read | |||
| DescribeLocationFsxOpenZfs | Grants permission to view metadata, such as the path information about an Amazon FSx OpenZFS sync location | Read | |||
| DescribeLocationFsxWindows | Grants permission to view metadata, such as the path information about an Amazon FSx Windows sync location | Read | |||
| DescribeLocationHdfs | Grants permission to view metadata, such as the path information about an Amazon HDFS sync location | Read | |||
| DescribeLocationNfs | Grants permission to view metadata, such as the path information, about a NFS sync location | Read | |||
| DescribeLocationObjectStorage | Grants permission to view metadata about a self-managed object storage server location | Read | |||
| DescribeLocationS3 | Grants permission to view metadata, such as bucket name, about an Amazon S3 bucket sync location | Read | |||
| DescribeLocationSmb | Grants permission to view metadata, such as the path information, about an SMB sync location | Read | |||
| DescribeTask | Grants permission to view metadata about a sync task | Read | |||
| DescribeTaskExecution | Grants permission to view metadata about a sync task that is being executed | Read | |||
| ListAgents | Grants permission to list agents owned by an AWS account in a region specified in the request | List | |||
| ListLocations | Grants permission to list source and destination sync locations | List | |||
| ListTagsForResource | Grants permission to list tags that have been added to the specified resource | Read | |||
| ListTaskExecutions | Grants permission to list executed sync tasks | List | |||
| ListTasks | Grants permission to list of all the sync tasks | List | |||
| StartTaskExecution | Grants permission to start a specific invocation of a sync task | Write | |||
| TagResource | Grants permission to apply a key-value pair to an AWS resource | Tagging | |||
| UntagResource | Grants permission to remove one or more tags from the specified resource | Tagging | |||
| UpdateAgent | Grants permission to update the name of an agent | Write | |||
| UpdateLocationHdfs | Grants permission to update an HDFS sync Location | Write | |||
| UpdateLocationNfs | Grants permission to update an NFS sync Location | Write | |||
| UpdateLocationObjectStorage | Grants permission to update a self-managed object storage server location | Write | |||
| UpdateLocationSmb | Grants permission to update a SMB sync location | Write | |||
| UpdateTask | Grants permission to update metadata associated with a sync task | Write | |||
| UpdateTaskExecution | Grants permission to update execution of a sync task | Write |
Resource types defined by AWS DataSync
The following resource types are defined by this service and can be used in the
Resource
element of IAM permission policy statements. Each action in the
Actions table
identifies the resource types that can be specified with that action. A resource type can also define which condition keys you can include in a policy. These keys are displayed in the last column of the table. For details about the columns in the following table, see
Resource types table
.
| Resource types | ARN | Condition keys |
|---|---|---|
| agent |
arn:$
{
Partition}:datasync:$
{
Region}:$
{
AccountId}:agent/$
{
AgentId}
|
|
| location |
arn:$
{
Partition}:datasync:$
{
Region}:$
{
AccountId}:location/$
{
LocationId}
|
|
| task |
arn:$
{
Partition}:datasync:$
{
Region}:$
{
AccountId}:task/$
{
TaskId}
|
|
| taskexecution |
arn:$
{
Partition}:datasync:$
{
Region}:$
{
AccountId}:task/$
{
TaskId}/execution/$
{
ExecutionId}
|
Condition keys for AWS DataSync
AWS DataSync defines the following condition keys that can be used in the
Condition
element of an IAM policy. You can use these keys to further refine the conditions under which the policy statement applies. For details about the columns in the following table, see
Condition keys table
.
To view the global condition keys that are available to all services, see Available global condition keys .
| Condition keys | Description | Type |
|---|---|---|
| aws:RequestTag/${TagKey} | Filters access by the tag key-value pairs in the request | String |
| aws:ResourceTag/${TagKey} | Filters access by the tag key-value pairs associated with the resource | String |
| aws:TagKeys | Filters access by the tag keys in the request | ArrayOfString |


Back door locked
Wake up alarm in master bedroom
Bathroom humidity reached threshold
Sam unlocked front door
Cloud backup completed


HPIT is a collection of machine learning and data management plugins for Intelligent Tutoring Systems. It is being developed through a partnership with Carnegie Learning and TutorGen, Inc and is based on the most recent research available.The goal of HPIT is to provide a scalable platform for the future development of intelligent tutoring systems, and an architecture that can accommodate both cognitive and non-cognitive factors in student modeling. HPIT by default consists of several different plugins which users can store, track, and query for information. As of today we support Bayesian Knowledge Tracing, Model Tracing, Adaptive Hint Generation, and data storage and retrieval. HPIT is in active development and should be considered unstable for everyday use.
To install the client libraries make sure you are using the most recent version of Python 3.4.
sudo apt-get install python3 python-virtualenv
brew install python3 pyenv-virtualenv
Setup a virtual environment: virtualenv -p python3 env
source env/bin/activate
source env/bin/activate
pip3 install -r test_requirements.txt
nosetests
Go to https://www.hpit-project.org/user/register and create a new account.
There are various settings which change the behavior of the client side libraries.
| name | default | description |
|---|---|---|
| HPIT_URL_ROOT | 'https://www.hpit-project.org' | The URL of the HPIT server. |
| REQUESTS_LOG_LEVEL | 'debug' | The logging level of the requests library. |
To override the clientside settings in your app do the following. You will need to override the HPIT URL if you are doing any local testing.
python
from hpitclient.settings import HpitClientSettings
settings = HpitClientSettings.settings()
settings.HPIT_URL_ROOT = 'http://<IP_ADDRESS>:8000'
To create a new plugin, first go https://www.hpit-project.org and log in. Then click on "My Plugins" and add a new plugin. Give it a brief name and a description. Click Submit. The next page will generate two items you will need to connect to the centralized HPIT router. Copy and securly store the Entity ID and API Key An Entity ID and an API Key. We do not store API Keys on the server so if you lose it you will need to generate a new one.
To create a new plugin you'll need to derive from the Plugin class.
```python from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
entity_id = 'YOUR_PLUGIN_ENTITY_ID' #eg. b417e82d-4153-4f87-8a11-8bb5c6bfaa00
api_key = 'YOUR_PLUGIN_API_KEY' #eg. ae29bd1b81a6064061eca875a8ff0a8d
#Call the parent class's init function
super().__init__(entity_id, api_key)
```
Calling the start method on the plugin will connect it to the server.
```python
my_plugin = MyPlugin() my_plugin.start() ```
Plugins are event driven. The start method connects to the server then starts an endless loop. There are
several hooks that can be called in this process. One of these hooks is the post_connect
hook and id
called after successfully connecting to the server. This is where you can register the messages you want
your plugin to listen for, and the callback functions it should employ when your plugin receives a message
of that type.
Let's define one now:
```python from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
...
def post_connect(self):
super().post_connect()
#Subscribe to a message called 'echo'
self.subscribe(echo=self.my_echo_callback)
def my_echo_callback(self, message):
print(message['echo_text'])
```
The self.subscribe
method takes a message name and a callback. In this case echo
is the message name and
self.my_echo_callback
is the callback that will be used when a message named 'echo' is sent to the plugin. It
then contacts the HPIT central router and tells it to start storing messages with that name of echo
so this plugin
can listen to and respond to those messages.
A message in HPIT consists of a message name, in this case echo
, and a payload. The payload can
have any arbitrary data in it that a tutor wishes to send. The payload is determined by the Tutor, and the
HPIT router doesn't care what data is in the payload. It is up to the plugin to parse and validate the payload.
Plugin developers should document what messages their plugins receive and what data types and values the payload
should contain.
If a tutor sends a message like "echo" -> {'echo_text' : "Hello World!"}
through HPIT, this plugin
will receive that message and print it to the screen. If 'echo_text' isn't in the payload the callback would
throw a KeyError exception, which in practice, should be handled.
```python
from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
...
def post_connect(self):
...
def my_echo_callback(self, message):
if 'echo_text' in message:
print(message['echo_text'])
```
In the inner loop of the start method a few things happen. The plugin asks the HPIT router server if any messages
that it wants to listen to are queued to be sent to the plugin. Then if it receives new messages it dispatches them
to the assigned callbacks that were specified in your calls to self.subscribe
Plugins can also send responses back to the original sender of messages. To do so the plugin needs to call the
self.send_response
function. All payloads come with the message_id
specified so we can route responses appropriately.
To send a response we'll need to slightly modify our code a bit.
```python
from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
...
def post_connect(self):
...
def my_echo_callback(self, message):
if 'echo_text' in message:
#Print the echo message
print(message['echo_text'])
#Send a response to the message sender
my_response = {
'echo_response': message['echo_text']
}
self.send_response(message['message_id'], my_response)
```
The original tutor or plugin who sent this message to MyPlugin will get a response back
with the echo_response
parameter sent back.
Just like tutors, plugins can also send messages to other plugins through HPIT. It is possible to "daisy chain" plugins together this way where you have a tutor send a message, which gets sent to a plugin (A), which queries another plugin for information (B), which does the same for another plugin (C), which sends back a response to plugin B, which responds to plugin A, which responds to the original Tutor.
The goal with this is that each plugin can handle a very small task, like storing information, do some logging, update a decision tree, update a knowledge graph, or etc, etc. The possibilities are endless.
Our plugin all put together now looks like:
```python from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
entity_id = 'YOUR_PLUGIN_ENTITY_ID' #eg. b417e82d-4153-4f87-8a11-8bb5c6bfaa00
api_key = 'YOUR_PLUGIN_API_KEY' #eg. ae29bd1b81a6064061eca875a8ff0a8d
#Call the parent class's init function
super().__init__(entity_id, api_key)
def post_connect(self):
super().post_connect()
#Subscribe to a message called 'echo'
self.subscribe(echo=self.my_echo_callback)
def my_echo_callback(self, message):
if 'echo_text' in message:
#Print the echo message
print(message['echo_text'])
#Send a response to the message sender
my_response = {
'echo_response': message['echo_text']
}
self.send_response(message['message_id'], my_response)
if name == 'main': my_plugin = MyPlugin() my_plugin.start() ```
There are several hooks throughout the main event loop, where you can handle some special cases. The only hook
that MUST be defined in a plugin is the post_connect
hook. It is where you should define the messages and handlers
that the plugin to listen and possibly respond to.
To stop the plugin from running you can either send a SIGTERM or SIGKILL signal to it eg. (sudo kill -9 plugin_process_id
), OR
you can press CTRL+C, OR you can return False from a hook. A signal, control+c, and returning False from a hook are considered
graceful by the library and not only will the plugin terminate, it will send a disconnect message to the server, which will
destroy the authentication session with the server, and the HPIT server will continue storing messages for you to retrieve
later.
Disconnecting from the HPIT server will not cause HPIT to forget about you; it will continue storing messages for you which you can receive the next time you run your plugin.
 A good place to do this is in the pre_disconnect
hook.
```python from hpitclient import Plugin
class MyPlugin(Plugin):
def __init__(self):
pass
def post_connect(self):
super().post_connect()
#Subscribe to a message called 'echo'
self.subscribe(echo=self.my_echo_callback)
def pre_disconnect(self):
#Unsubscribe to the 'echo' message
self.unsubscribe('echo')
```
Here are some other places you can hook into the event loop. Returning False from any of them, will cause the event loop to terminate.
| Hook Name | Called When: |
|---|---|
| pre_connect | Before the plugin connects and authenticates with the server. |
| post_connect | After the plugin connects and authenticates with the server. |
| pre_disconnect | Before the plugin disconnects from the server. |
| post_disconnect | After the plugin disconnects from the server. (Right before exit) |
| pre_poll_messages | Before the plugin polls the server for new messages. |
| post_poll_messages | After the plugin polls the server for new messages but before dispatch. |
| pre_dispatch_messages | Before the messages are dispatched to their callbacks. |
| post_dispatch_messages | After the messages are dispatched to their callbacks. |
| pre_handle_transactions | Before the plugin polls the server for new PSLC Datashop transactions. |
| post_handle_transcations | After the plugin polls the server for new PSLC Datashop transactions. |
| pre_poll_responses | Before the plugin polls the server for new responses to it's messages. |
| post_poll_responses | After the plugin polls the server for new responses but before dispatch. |
| pre_dispatch_responses | Before the plugin dispatches it's responses to response callbacks. |
| post_dispatch_responses | After the plugin dispatches it's responses to response callbacks. |
To create a new tutor, first go https://www.hpit-project.org and log in. Then click on "My Tutors" and add a new tutor. Give it a brief name and a description. Click Submit. The next page will generate for you two items you'll need to us to connect to the centralized HPIT router. Copy the Entity ID and API Key in a local, secure place. We do not store API Keys on the server, so if you lose it, you'll need to generate a new one.
To create a new tutor you'll need to derive from the Tutor class.
```python from hpitclient import Tutor
class MyTutor(Tutor):
def __init__(self):
entity_id = 'YOUR_PLUGIN_ENTITY_ID' #eg. b417e82d-4153-4f87-8a11-8bb5c6bfaa00
api_key = 'YOUR_PLUGIN_API_KEY' #eg. ae29bd1b81a6064061eca875a8ff0a8d
super().__init__(entity_id, api_key, self.main_callback)
def main_callback(self):
print("Main Callback Loop")
response = self.send('echo', {'test': 1234})
```
Tutors differ from plugins in one major way, in their main event loop they call a callback function which will be called during each iteration of the main event loop. This callback is specified in a parameter in the init function. After calling the main callback function, the main event loop then polls HPIT for responses from plugins which you have sent messages to earlier.
To send a message to HPIT and have that message routed to a specific plugin you can call the self.send
method as we do above. Messages sent this way consist of an event name (in this case 'echo') and a dictionary
of data. Optionally you can specify a response callback as we do below. All messages sent through HPIT are
multicast and every plugin which 'subscribes' to those messages will receive them, including the echo plugin
you created and registered with HPIT in the last tutorial.
```python class MyTutor(Tutor): ...
def main_callback(self):
response = self.send('echo', {'test': 1234}, self.response_callback)
def response_callback(self, response):
print(str(response))
```
When you send a message to HPIT you can specify a response callback to the send method. After the message is received and processed by a plugin, it may optionally send a response back. If it does the response will travel back through HPIT, where when polled by this library, will route that response to the callback you specified. You can then process the response however you would like in your Tutor. Here, we are just echoing the response back to the console. Responses you recive will be a dictionary consisting of the following key-value pairs.
| Key (. denotes sub-dictionary) | Value |
|---|---|
| message_id | The ID generated to track the message. |
| message.sender_entity_id | Your Entity ID. |
| message.receiver_entity_id | The Plugin's Entity ID that is responding to your message. |
| message.time_created | The time HPIT first received your message. |
| message.time_received | The time HPIT queued the message for the plugin to consume. |
| message.time_responded | The time HPIT received a response from the plugin. |
| message.time_response_received | The time HPIT sent the response back to your tutor. |
| message.payload | What you originally sent to HPIT. |
| message.message_name | What you named the message. |
| response | A dictionary of values the Plugin responded to the message with. |
Since multiple plugins may respond to the same message that you sent out, you may wish to check the contents of the response payload, as well as the message.receiver_entity_id to help filter the responses you actually want to handle. You can specify different callbacks for the same message, as well as a "global" callback for one message. For example both:
```python class mytutor(tutor): ...
def main_callback(self):
response = self.send('echo', {'test': 1234}, self.response_callback)
response = self.send('echo_two', {'test': 1234}, self.response_callback)
def response_callback(self, response):
print(str(response))
```
AND
```python class mytutor(tutor): ...
def main_callback(self):
response = self.send('echo', {'test': 1234}, self.response_callback)
response = self.send('echo', {'test': 1234}, self.response_callback_two)
def response_callback(self, response):
print(str(response))
def response_callback_two(self, response):
logger.log(str(response))
```
are valid ways to handle responses from plugins.
In HPIT, a transaction is supposed to be the smallest unit of interaction a student has with a tutor. The PSLC datashop uses transactions in its analysis of learning; it is the most fine grained representation of a student's skill set. Transactions can be generated by the student, like a key being pressed or an answer selected, or by the tutor, as in the tutor tells HPIT that the student was correct in answering a question.
For a Tutor, to utilize transactions, developers should make use of the send_transaction() method, which functions similarly to the send() method, except it issues a special "transaction" message to HPIT.
For a Plugin, they must specifically set a transaction callback using register_transaction_callback(), which also subscribes a tutor to transaction messages.
Currently, there are several active plugins on HPIT's production servers which you can query for information. These include: knowledge tracing plugin; hint factory plugin; boredom detector plugin; student manager plugin. The knowledge tracing plugin is responsible for handling Bayesian knowledge tracing, the hint factory handles domain model generation and hint generation, the boredom detector plugin provides either a boredom indicator (true/false) or boredom percentage indicator, and the student manager plugin allows for setting and retrieving any standard or custom student attributes.
Documentation on these plugins are available from https://www.hpit-project.org/docs


ALSAPLAYER(1) ALSAPLAYER(1) NAME alsaplayer - plays various sound files SYNOPSIS alsaplayer [options] [ filename ...] DESCRIPTION This manual page documents briefly the alsaplayer command. This manual page was written for the Debian GNU/Linux distribution because the origi‐ nal program does not have a manual page. alsaplayer is a generic music player that can play back a large amount of file formats. If files are specified on the command line, these files are played. Oth‐ erwise alsaplayer plays its playlist from its last run, if any. FILENAME Play the specified file(s). Can be a file or an URL. CD.cdda Special filename. Play a CD. /dev/cdrom will be used by default. Otherwise, AlsaPlayer will use the device specified in your config file (usually ~/.alsaplayer/config). OPTIONS These programs follow the usual GNU command line syntax, with long options starting with two dashes (`-'). A summary of options is included below. -c, --config <file> Use the given config file for this session. -h, --help Print this help message. -i, --interface <interface> Use the specified interface instead of the default one. -I, --script <file> Specify the script to pass to the interface plugin. -l, --startvolume <vol> Start with this volume [default=1.0]. -p, --path <path> Set the path alsaplayer looks for add-ons. -q, --quiet Quiet operation, no output. -s, --session-name name Name this session "name" -v, --version Print version of this program. --verbose Be verbose about the output. --nosave Do not save playlist content at exit. Player control: -n, --session # Select session # [default=0] -e, --enqueue file(s) Enqueue file(s) in a running alsaplayer. -E, --replace file(s) Clears and queues file(s) in a running alsaplayer. --status Get some information about the session. --volume # Set software volume [0.0-1.0]. --start Start playing. --stop Stop playing. --pause Pause/unpause playing. --prev Jump to the previous track. --next Jump to the next track. --seek <second> Jump to the specified second in the current track. --relative <second> Jump <second> seconds from current position. --speed # Set the playback speed. 1.0 = normal speed, -1.0 = normal speed backwards --jump # Jump to the specified playlist track. --clear Clear the whole playlist --quit Quit the session. Sound driver options: -d, --device string Select the specific device for the output plugin. For the ALSA plugin, the default is "default". For the JACK plugin, the default is "alsa_pcm:playback_1,alsa_pcm:playback_2". -f, --fragsize # Set fragment size in bytes [default=4096]. -F, --frequency # Set the output frequency [default=44100]. -g, --fragcount # Fragment count [default=8]. -r, --realtime Enable realtime scheduling. To use this as a normal user, alsaplayer must be SUID root. -o, --output [alsa|esound|jack|nas|null|oss|sgi|sparc] Use the specified output driver. Experimental options: -S,--loopsong Loop the file. -P,--looplist Loop the playlist. -x,--crossfade Crossfade playlist entries. JACK OUTPUT PLUGIN For use with JACK, -F <sample_rate> is mandatory for best results. The value of sample rate must be the same as the one used by jackd. If you forget the -F parameter, the sound can be very bad. The only rem‐ edy at that time is to restart both jackd and AlsaPlayer. DAEMON INTERFACE With the daemon interface, it is mandatory to add the -s option. You must process in two steps to get sound with it. First launch the daemon: alsaplayer -i daemon -s <name> and then add some song: alsaplayer -e <some.song> GTK INTERFACE The gtk interface provide some basic keyboard controls: v Stop x Play c Pause b Next Song z Previous Song g Seek Forward a Seek Backward f Forward Play s Reverse Play t Speed Up one musical semitone. (handy for changing the key the song is played back in) q Speed Down one musical semitone. h Speed Up one comma. (handy to tune the song instead of the guitar when playing at the same time as listening) i Speed Down one comma. r Volume Up w Volume Down l Loop PREFERENCES AlsaPlayer have a preferences file located in ~/.alsaplayer/config. To modify the preferences setting by hand, you must exit from the running program and edit this file. The default value is put in the description below when appropriate: General settings main.default_interface=gtk2 Specify the default interface. main.default_output=alsa Specify the default sound server. main.multiopen=true Specify if it is possible to run multiple AlsaPlayer instances. main.period_count=8 Number of periods in the sound buffer main.period_size=4096 Frames per period in the sound buffer Output settings jack.output1=alsa_pcm:playback_1 Output device 1 when using JACK sound server jack.output2=alsa_pcm:playback_2 Output device 2 when using JACK sound server Input settings cdda.cddb_servername=freedb.freedb.org Server used by the cdda input module to retrieve the cddb informa‐ tion. cdda.cddb_serverport=80 Port used by the cdda input module to retrieve the cddb informa‐ tion. cdda.device=/dev/cdrom Device used by the cdda input module to retrieve the CD. cdda.do_cddb_lookup=true Must AlsaPlayer retrieve or not the cddb information. http.buffer_size=1048576 Size of the input buffer when <filename> is an URL. mad.parse_id3=true Parse or not the Id3 tags. GTK interface settings gtk_interface.default_play_path=~/ Default path used by the Add file function gtk_interface.default_playlist_add_path=/ Default path used by the Add file function in the Playlist window gtk_interface.default_playlist_load_path=/ Default path used by the Load playlist function gtk_interface.default_playlist_save_path=/ Default path used by the Save playlist function gtk_interface.playlist_active=false Launch or not the playlist window at start up. gtk_interface.sopeswindow_active=false Launch or not the scopes selector window at start up. gtk_interface.smooth_transition=false Will functions such as pause use a smooth speed transition. GTK2 interface settings It use the same options as the GTK interface but with "gtk2_" as prefix instead of "gtk_". XOSD interface settings xosd_interface.color=#55ff55 Colour used by the XOSD interface. xosd_interface.font=-adobe-helvetica-medium-r-normal-*-24-*-*-*-*-*-*-* xosd_interface.h_offset=20 Display horizontal offset from the left of the screen xosd_interface.timeout=5 Set the display time. xosd_interface.v_offset=20 Display vertical offset from the top of the screen Scopes settings blurscope.active=false Launch or not the blurscope plugin at start up. fftscope.active=false Launch or not the fftscope plugin at start up. levelmeter.active=false Launch or not the levelmeter scope plugin at start up. logbarfft.active=false Launch or not the logbar scope plugin at start up. opengl_spectrum.active=false Launch or not the spectrumgl scope plugin at start up. opengl_spectrum.height=480 Height of the spectrumgl scope plugin opengl_spectrum.width=640 Width of the spectrumgl scope plugin opengl_spectrum.active=false spacescope.active=false Launch or not the spacescope plugin at start up. synaescope.active=false Launch or not the synaescope plugin at start up. SEE ALSO mikmod(1), mpg123(1). AUTHOR This manual page was written by Ivo Timmermans<EMAIL_ADDRESS>for the Debian GNU/Linux system (but may be used by others). FILENAME, GTK, DAE‐ MON INTERFACE and PREFERENCES sections added by Dominique Michel<EMAIL_ADDRESS>from the Alsaplayer team. 8 September 2007 ALSAPLAYER(1)


Our Products
for Cats
for Dogs
for Small Pets
Other Products
Login
Register
Your source for pet-safe bath supplies.
Color Samples
#D4D8E6
#41A8AC
#7BBFC8
#A6CDC6
#DAD5D3
#DDDFE3
Customer Service
Shipping Options
What is "Pet-Safe?"
Our Suppliers
SudsyPup
111 Local Street
Your Town, AK 01010
1-800-111-1234
FAQ
Feedback
Our Pets
Adopt a Pet


Check your internet connection. If that's not it, try refreshing the page. If that still doesn't help, check with your administrator.


val waitForSleepTimeInMilliseconds: Long
Overrides ConfigurationSetup.waitForSleepTimeInMilliseconds
control the amount of time between attempts when using com.github.epadronu.balin.core.WaitingSupport.waitFor.
waitForSleepTimeInMilliseconds
- control the amount of time between attempts when using com.github.epadronu.balin.core.WaitingSupport.waitFor.


Fun fact: The Presidential turkey pardon, is a long-standing tradition that was started in 1947 by President Truman.
seriously... where is it?
github.com/charmcityjs/talks
NodeSchool!
- Next one: Sunday, November 12, 2017 1-5pm @ Betamore
- We're looking for mentors AND attendees!!!
B'More on Rails Meetup
- Next one: Tuesday, November 14, 2017 7-9pm @ Allovue
- Topic: Security, Machine Learning, ???
After the talks, EVERYONE must join us at The Port Public House!
1229 Hull Street


Basic Information
Name
Email address
Password
File upload
Upload
Candidate Description / Bio
Submit
Cancel


SimplePalette without input field.
SimplePalette with input field. (For palettes, thanks to https://www.color-hex.com/color-palettes/)
Colpicker with palette hidden.
Colpicker with palette visible and scaled bigger.
Browser's native input[type="color"].


Located in a peaceful bungalow outside of Lake Geneva, Wisconsin.
Retreat from the desk, return refreshed!
About Unplugged Retreats - no bad wifi.
12 private rooms with ensuite bathrooms, 2 group meeting rooms, and 4 breakout rooms.
Private chef team providing on-demand meals - just link your team kitchen.
5 outdoor obstacle courses, including private beach 1/2 mile from bungalow.
Retreat facilitator to manage your day to day activities so you will all get a chance to reset.
Dedicated computer room for times that you must use wifi.
Be a better team in 5 days. This and other teams did!
LaCrue Bottling Co. October 2019
The team at LaCrue Bottling is one of the many we have helped become a more focused and results-driven team. After being able to relax and let go of their day-to-day responsibilities they had a breakthrough better than any of them could have imagined. After the 5-day retreat, they are now moving forward in the same direction with the same end in sight!


glow.dom
glow.dom.NodeList#scrollLeft & scrollTop on an element
This is provided as a manual test to ensure the element visually scrolls
Get the current scroll position of the element below
It should be 'Left: 0, Top: 0' when the scrollbars are at the far left & top
Set the scroll position to 'Left: 100, Top: 200'
A green box should appear in the top left of the element
Get the scroll position again, it should read 'Left: 100, Top: 200'
Set the scroll position to 'Left: 3000, Top: 3000'
The element should scroll to the bottom right
glow.dom.NodeList#scrollLeft & scrollTop on the window
Give this window some scrollbars
Get the current scroll position of the window
It should be 'Left: 0, Top: 0' when the scrollbars are at the far left & top
Set the scroll position to 'Left: 100, Top: 200'
Get the scroll position again, it should read 'Left: 100, Top: 200'
Set the scroll position to 'Left: 3000, Top: 3000'
The window should scroll to the bottom right


reads a sheet from a workbook or file (workbook can either be a workbook or worksheet).
Caution
Rough function!
This is still really rough, so be careful when using.
| Returns: | a tuple of (workbook, worksheet) for given workbook and sheet_name |
|---|
Parameters:
| Parameters: |
|
|---|
excel-specific wrapper for make_filename
Takes a given list of dicts and converts it to an excel file, using similar settings to write_dict in csv.
Special Parameters:
| Parameters: |
|
|---|
for each entry, write_dict() will lookup to see if there exists a row_style or a column_style corresponding to that entry returns worksheet created (note can get workbook from worksheet by: worksheet.parent)


Your primary resource for all application procedures.
Not quite sure whether your proposal fits? Submit a Letter of Intent first! A Letter of Intent contains a 200-word description of your project, including contact name, email and affiliation, brief project description, targeted postdocs, to<EMAIL_ADDRESS>The SPIF committee will review your idea before going to the full application.
You can also skip the above process and directly go Full Proposal Submission.
Please submit a Progress Report/Follow-up Form and go through the Full Proposal Submission, indicating its a renewal proposal in the "Additional Information / Comments" section.


222. Reserved Keys
Up: Process Manager Interface
Next: Spawn Example
Previous: Starting Multiple Executables and Establishing Communication
The following keys are reserved. An
implementation is not required to interpret these keys, but if it does
interpret the key, it must provide the functionality described.
-
host
-
Value is a hostname. The format of the hostname is determined by
the implementation.
-
arch
-
Value is an architecture name. Valid architecture names and
what they mean are determined by the implementation.
-
wdir
-
Value is the name of a directory on a machine on which
the spawned process(es) execute(s).
This directory is made the working directory of the executing process(es).
The format of the directory name is determined by the implementation.
-
path
-
Value is a directory or set of directories
where the implementation should look for the executable.
The format of path is determined by the implementation.
-
file
-
Value is the name of a file in which additional information
is specified. The format of the filename and internal format of the file
are determined by the implementation.
-
soft
-
Value specifies a set of numbers which are allowed values
for the number of processes that MPI_COMM_SPAWN (et al.) may create.
The format of the value is a comma-separated list of Fortran-90
triplets each of which specifies a set of integers and which together specify
the set formed by the union of these sets.
Negative values in this set and values greater than maxprocs are
ignored. MPI will spawn the largest number of processes it can,
consistent with some number in the set. The order in which
triplets are given is not significant.
By Fortran-90 triplets, we mean:
1. a means a
2. a:b means a, a+1, a+2, ..., b
3. a:b:c means a, a+c, a+2c, ..., a+ck,
where for c > 0, k is the largest integer for which
and for c < 0, k is the largest integer
for which
.
If b > a then c must be positive. If b < a then c must be negative.
Examples:
1. a:b gives a range between a and b
2. 0:N gives full ``soft'' functionality
3. 1,2,4,8,16,32,64,128,256,512,1024,2048,4096 allows
a power-of-two number of processes.
4. 2:10000:2 allows an even number of processes.
5. 2:10:2,7 allows 2, 4, 6, 7, 8, or 10 processes.
Up: Process Manager Interface
Next: Spawn Example
Previous: Starting Multiple Executables and Establishing Communication
Return to MPI-3.1 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-3.1 of June 4, 2015
HTML Generated on June 4, 2015


--- title: els date: 1998-09-08T10:00:00.000Z gender: Uncertain homePage: els is the third person who will unfortunately suffer for putting my url as her own. The consequences are dead serious and not funny. city: Sydney thinkLotrRules: Of course ---
hey there person....i am a frend of ur cousin...talia...i go to skool with her..aint that cool. byebye ah yeah ur page is real cool to...


2.1.1
- Fixes a compatibility issue with
modular-css
- now the module will only
use the raw selector value if it equal to the ‘cleaned’ selector value.
2.1.0
- Adds support for converting between similar
:nth-child
selectors. For
example, :nth-child(1)
can be converted to :first-child
, and
p:nth-last-child(2n + 1)
converts to p:nth-last-child(odd)
.
2.0.7
- Fixes a regression where postcss-minify-selectors would transform
[title=""]
into [title=]
(thanks to @arperry).
2.0.6
- Performance tweaks; now calls
Node#toString()
~50% less often, removed dead
branches, extracted each node type into a separate transformer function.
- Resolves an issue where extraneous whitespace around a case-insensitive
attribute selector (
[href="foo" i]
) would not be removed.
2.0.5
- Updated postcss-selector-parser to
2.0.0
.
2.0.4
- Now compiled with babel 6.
2.0.3
- Fixed an issue where
[a="-"]
was incorrectly minified to [a=-]
.
2.0.2
- Fixed a crash with Polymer mixins; now the module will pass through any
selector string with a trailing colon.
2.0.1
- Replaced javascript-natural-sort with alphanum-sort (thanks to @TrySound).
2.0.0
- Upgraded to PostCSS 5.
- At-rule parameter minification was extracted out of this module into
postcss-minify-params (thanks to @TrySound).
1.5.0
- Added support for converting pseudo elements with double colon syntax to
the single colon syntax.
1.4.7
- Further performance improvements by using less postcss-selector-parser
iterations.
1.4.6
- Bump normalize-selector to
0.2.0
, decreases overall package weight.
- Speed up node iteration by calling
eachInside
once rather than twice.
1.4.5
- Update normalize-selector to cut down package weight.
1.4.4
- Fixed an integration issue with postcss-font-magician.
1.4.3
- Fixed an issue where
.from
was transformed to 0%
.
1.4.2
- Bump dependencies.
- Fixes for PostCSS plugin guidelines.
1.4.1
- Fixes incorrect deduplication of pseudo selector rules.
1.4.0
- Update to postcss-selector-parser to greatly improve parsing logic.
1.3.1
- Fixes a crash when nothing was passed to
node-balanced
.
1.3.0
- Now uses the PostCSS
4.1
plugin API.
1.2.1
- Passes original test case in issue 1.
1.2.0
- Does not touch quoted values in attribute selectors.
- No longer will mangle values such as
2100%
in keyframes.
1.1.0
- Now minifies
from
to 0%
and 100%
to to
in keyframe declarations.
1.0.0


From Trusted Foundries and precision processes to highly cost optimized solutions, our foundry partners provide the essential silicon fabrication expertise to realize our designs with high yield and superior quality.
Our package capabilities are extensive. Customers may select the package that works best with their assembly process. From state of the art RoHS/REACH Wafer Scale packaging to pin for pin compatible DIP replacements and everything in between.
Custom automated tests are developed for each part to verify critical design parameters specified by the design requirements. Through our test partners we leverage state of the art testers with capital expenses over $1MM with only minimal cost to our customers.
We acknowledge that many companies leverage distribution in their operations. Triad parts may be purchased direct or with the added benefits of Avnet, our distribution partner.


Chapter 3 Literature
Here is a review of existing methods. To begin with I have simply forked the rbooks repo and started to add to this along with the shiny library:
A curated list of books about different aspects and applications of R programming language and an attempt to modernize R Books in a more user friendly way. Inspired by GoBooks.
3.1 Beginner Books
<IP_ADDRESS> Learning R [Amazon]
Learn how to perform data analysis with the R language and software environment, even if you have little or no programming experience. With the tutorials in this hands-on guide, you’ll learn how to use the essential R tools you need to know to analyze data, including data types and programming concepts.
<IP_ADDRESS> Hands-On Programming with R [Amazon]
Learn how to program by diving into the R language, and then use your newfound skills to solve practical data science problems. With this book, you’ ll learn how to load data, assemble and disassemble data objects, navigate R’s environment system, write your own functions, and use all of R’s programming tools.
<IP_ADDRESS> The R Book [Amazon]
Very massive, hugely successful and popular text presenting an extensive and comprehensive guide for all R users. Covers wide variaty of R topics in great detail with very useful examples.
<IP_ADDRESS> R for Everyone: Advanced Analytics and Graphics [Amazon]
Drawing on his unsurpassed experience teaching new users, professional data scientist Jared P. Lander has written the perfect tutorial for anyone new to statistical programming and modeling. Organized to make learning easy and intuitive, this guide focuses on the 20 percent of R functionality you’ll need to accomplish 80 percent of modern data tasks. Book’s self-contained chapters start with the absolute basics, offering extensive hands-on practice and sample code. You’ll download and install R; navigate and use the R environment; master basic program control, data import, and manipulation; and walk through several essential tests. Then, building on this foundation, you’ll construct several complete models, both linear and nonlinear, and use some data mining techniques.
<IP_ADDRESS> R Cookbook [Amazon]
With more than 200 practical recipes, this book helps you perform data analysis with R quickly and efficiently. The R language provides everything you need to do statistical work, but its structure can be difficult to master. This collection of concise, task-oriented recipes makes you productive with R immediately, with solutions ranging from basic tasks to input and output, general statistics, graphics, and linear regression.
<IP_ADDRESS> Learn R in a Day [Amazon]
‘Learn R in a Day’ provides the reader with key programming skills through an examples-oriented approach and is ideally suited for academics, scientists, mathematicians and engineers. The book assumes no prior knowledge of computer programming and progressively covers all the essential steps needed to become confident and proficient in using R within a day. Topics include how to input, manipulate, format, iterate (loop), query, perform basic statistics on, and plot data, via a step-by-step technique and demonstrations using in-built datasets which the reader is encouraged to replicate on their computer. Each chapter also includes exercises (with solutions) to practice key skills and empower the reader to build on the essentials gained during this introductory course.
<IP_ADDRESS> R Inferno [Online] Free
“If you are using R and you think you’re in hell, this is a map for you.”
This is a great introduction to several aspects of R programming. Loading data into R, iterating over data with loops & logic statements, author even touches on creating packages. Nice and pretty thorough book on R.
<IP_ADDRESS> The R Programming Wikiboo [online]
A collaborative book about R on the wikibooks website. Anyone can improve it.
<IP_ADDRESS> Data Munging with R [Manning]
Data Munging with R shows you how to take raw data and transform it for use in computations, tables, graphs, and more. Whether you already have some programming experience or you’re just a spreadsheet whiz looking for a more powerful data manipulation tool, this book will help you get started.
You’ll discover the ins and outs of using the data-oriented R programming language and its many task-specific packages. With dozens of practical examples to follow, learn to fill in missing values, make predictions, and visualize data as graphs. By the time you’re done, you’ll be a master munger, with a robust, reproducible workflow and the skills to use data to strengthen your conclusions!
<IP_ADDRESS> R for Data Science [Online] Free
Learn how to use R to turn raw data into insight, knowledge, and understanding. This book introduces you to R, RStudio, and the tidyverse, a collection of R packages designed to work together to make data science fast, fluent, and fun. Suitable for readers with no previous programming experience, R for Data Science is designed to get you doing data science as quickly as possible.
3.2 Advanced Books
<IP_ADDRESS> Advanced R [Online] [Amazon] Free
Advanced R presents useful tools and techniques for attacking many types of R programming problems, helping you avoid mistakes and dead ends. With more than ten years of experience programming in R, the author illustrates the elegance, beauty, and flexibility at the heart of R.
<IP_ADDRESS> Data Manipulation with R, Second Edition [Packt]
This book starts with the installation of R and how to go about using R and its libraries. We then discuss the mode of R objects and its classes and then highlight different R data types with their basic operations.
The primary focus on group-wise data manipulation with the split-apply-combine strategy has been explained with specific examples. The book also contains coverage of some specific libraries such as lubridate, reshape2, plyr, dplyr, stringr, and sqldf. You will not only learn about group-wise data manipulation, but also learn how to efficiently handle date, string, and factor variables along with different layouts of datasets using the reshape2 package.
By the end of this book, you will have learned about text manipulation using stringr, how to extract data from twitter using twitteR library, how to clean raw data, and how to structure your raw data for data mining.
3.3 Data Science
<IP_ADDRESS> Mastering Data Science with R [Packt]
This book will give you the guidance you need to build and develop your knowledge and expertise. Bridging the gap between theory and practice, this book will help you to understand and use data for a competitive advantage.
Beginning with taking you through essential data mining and management tasks such as munging, fetching, cleaning, and restructuring, the book then explores different model designs and the core components of effective analysis. You will then discover how to optimize your use of machine learning algorithms for classification and recommendation systems beside the traditional and more recent statistical methods.
<IP_ADDRESS> Practical Data Science with R [Amazon]
Practical Data Science with R shows you how to apply the R programming language and useful statistical techniques to everyday business situations. Using examples from marketing, business intelligence, and decision support, it shows you how to design experiments (such as A/B tests), build predictive models, and present results to audiences of all levels.
This book is accessible to readers without a background in data science. Some familiarity with basic statistics, R, or another scripting language is assumed.
<IP_ADDRESS> R in Action: Data Analysis and Graphics with R [Amazon]
With more than 200 practical recipes, this book helps you perform data analysis with R quickly and efficiently. The R language provides everything you need to do statistical work, but its structure can be difficult to master. This collection of concise, task-oriented recipes makes you productive with R immediately, with solutions ranging from basic tasks to input and output, general statistics, graphics, and linear regression.
<IP_ADDRESS> R Programming for Data Science [Leanpub] Free
R in Action, Second Edition teaches you how to use the R language by presenting examples relevant to scientific, technical, and business developers. Focusing on practical solutions, the book offers a crash course in statistics, including elegant methods for dealing with messy and incomplete data. You’ll also master R’s extensive graphical capabilities for exploring and presenting data visually. And this expanded second edition includes new chapters on forecasting, data mining, and dynamic report writing.
<IP_ADDRESS> Exploratory Data Analysis with R [Leanpub] Free
This book teaches you to use R to effectively visualize and explore complex datasets. Exploratory data analysis is a key part of the data science process because it allows you to sharpen your question and refine your modeling strategies. This book is based on the industry-leading Johns Hopkins Data Science Specialization, the most widely subscribed data science training program ever created.
3.4 Finance
<IP_ADDRESS> Introduction to R for Quantitative Finance [Packt]
Introduction to R for Quantitative Finance will show you how to solve real-world quantitative finance problems using the statistical computing language R. The book covers diverse topics ranging from time series analysis to fi nancial networks. Each chapter briefl y presents the theory behind specific concepts and deals with solving a diverse range of problems using R with the help of practical examples.
This book will be your guide on how to use and master R in order to solve quantitative finance problems. This book covers the essentials of quantitative finance, taking you through a number of clear and practical examples in R that will not only help you to understand the theory, but how to effectively deal with your own real-life problems.
Starting with time series analysis, you will also learn how to optimize portfolios and how asset pricing models work. The book then covers fixed income securities and derivatives such as credit risk management.
<IP_ADDRESS> Mastering R for Quantitative Finance [Packt]
R is a powerful open source functional programming language that provides high level graphics and interfaces to other languages. Its strength lies in data analysis, graphics, visualization, and data manipulation. R is becoming a widely used modeling tool in science, engineering, and business.
The book is organized as a step-by-step practical guide to using R. Starting with time series analysis, you will also learn how to forecast the volume for VWAP Trading. Among other topics, the book covers FX derivatives, interest rate derivatives, and optimal hedging. The last chapters provide an overview on liquidity risk management, risk measures, and more.
The book pragmatically introduces both the quantitative finance concepts and their modeling in R, enabling you to build a tailor-made trading system on your own. By the end of the book, you will be well versed with various financial techniques using R and will be able to place good bets while making financial decisions.
3.5 Machine Learning
<IP_ADDRESS> Machine Learning with R [Amazon] [O’Reilly]
“Machine Learning with R” is a practical tutorial that uses hands-on examples to step through real-world application of machine learning. Without shying away from the technical details, we will explore Machine Learning with R using clear and practical examples. Well-suited to machine learning beginners or those with experience. Explore R to find the answer to all of your questions.
3.6 R Development
<IP_ADDRESS> R Packages [Online] [Amazon]
Packages are the fundamental units of reproducible R code. They include reusable R functions, the documentation that describes how to use them, and sample data. In this section you’ll learn how to turn your code into packages that others can easily download and use. Writing a package can seem overwhelming at first. So start with the basics and improve it over time. It doesn’t matter if your first version isn’t perfect as long as the next version is better.
3.7 Reports
<IP_ADDRESS> Dynamic Documents with R and knitr, Second Edition [Amazon]
Suitable for both beginners and advanced users, Dynamic Documents with R and knitr, Second Edition makes writing statistical reports easier by integrating computing directly with reporting. Reports range from homework, projects, exams, books, blogs, and web pages to virtually any documents related to statistical graphics, computing, and data analysis. The book covers basic applications for beginners while guiding power users in understanding the extensibility of the knitr package.
<IP_ADDRESS> Report Writing for Data Science in R [Leanpub] Free
This book teaches the fundamental concepts and tools behind reporting modern data analyses in a reproducible manner. As data analyses become increasingly complex, the need for clear and reproducible report writing is greater than ever. The material for this book was developed as part of the industry-leading Johns Hopkins Data Science Specialization.
3.8 Visualization
<IP_ADDRESS> R Data Visualization Cookbook [Amazon]
This book is packed with practical recipes, designed to provide you with all the guidance needed to get to grips with data visualization with R. It starts off with the basics of R plots and an introduction to heat maps and customizing them, before gradually taking you through creating interactive maps using the googleVis package, generating choropleth maps and contouring maps, bubble plots, and pie charts. You will then learn how to animate 2D and 3D plots in R. By the end of the book, you will be equipped with the key techniques to create impressive data visualizations with professional efficiency and precision.
<IP_ADDRESS> R Graphics Cookbook [Amazon]
This practical guide provides more than 150 recipes to help you generate high-quality graphs quickly, without having to comb through all the details of R’s graphing systems. Each recipe tackles a specific problem with a solution you can apply to your own project, and includes a discussion of how and why the recipe works.
Most of the recipes use the ggplot2 package, a powerful and flexible way to make graphs in R. If you have a basic understanding of the R language, you’re ready to get started.


EYE DROPS REDNESS AND DRY EYE RELIEF - naphazoline hydrochloride and glycerin solution/ drops
KC Pharmaceuticals, Inc.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
If swallowed, get medical help or contact a Poison Control Center right away.
For external use only
Do not use this product if
Ask a doctor before use if you have narrow angle glaucoma
When using this product
Stop use and ask a doctor if
benzalkonium chloride, boric acid, edetate disodium, purified water, and sodium borate
|
EYE DROPS REDNESS AND DRY EYE RELIEF
naphazoline hydrochloride, glycerin solution/ drops | ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
| ||||||||||||||||||||
|
| Labeler - KC Pharmaceuticals, Inc. (174450460) |
| Establishment | |||
| Name | Address | ID/FEI | Business Operations |
|---|---|---|---|
| KC Pharmaceuticals, Inc. | 174450460 | manufacture |


Version 0.1.5 - July 19, 2023
This web page and its content are a mirror of the Elvish Composition Archive: a collection of works in Tolkien’s Elvish languages, Quenya and Sindarin. Content is organized alphabetically by author. If you want to get (or even host) your own copy of the archive, see the section on mirrors, downloads and licensing. If you want to contribute to the archive, see the section on submissions.
Each author’s compositions are organized in chronological order of composition, with an indication of which Elvish language(s) they use. Note that the date of composition may not reflect when the composition was added to the archive. Because the works here are the writings of multiple authors, they do not necessarily represent a common vision of the Elvish languages, or the vision of Tolkien himself.
Currently the only way to submit new works to the archive is in the Vinyë Lambengolmor discord server, in its translations forum.
A downloadable version of this archive is available as a zip file, and the same content is available on various other mirrors web sites:
Not every mirror may have the same version, so check the version (and date) at the top of the archives home page. Some of the mirrors in this list may be defunct, especially if you have an old copy of the archive, but the content may still be available on other mirrors.
All of the content in this archive is licensed with some version of the non-commercial Creative Commons license:
This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
The copyrights are retained by the individual authors of each work, and each work is licensed separately. However, the license grants you the right to copy this archive for free. You may even rehost the content on your own web site. The license also grants you the right to create “derivative works”, so that you may excerpt or include compositions within educational or academic material.
Because this is a non-commercial license, you may not resell the compositions, nor charge money to access them. The archive (and any derivative works) must be non-commercial in nature. Hosting content on a site with separate advertising or other commercial activity (such as a web store or solicitations for contribution) is fine, as long as that advertising or other activities does not interfere with access to the archive itself, or its contents. Hosting the content on a site that requires a login is also fine, provided the site does not charge its customers money for that login or require some other kind of commercial interaction to gain access.
Since this license grants the right for derivative works, you may restyle the content to better fit your web site. The easiest way to do so it is modify the css/global.css file, since every page in the archive references that file. For example, you may want to modify the global CSS to pull in the style info/master CSS of your own web site. You can also edit the home page of the archive, to reflect its hosting on your site, including links to other pages on your site. It is preferred (but not required) that any modified archive content still be made available via a downloadable zip file, and any modifications include references to other known mirrors. You may want to add your mirror name to the version information at the top of the home page.
This licensing and distribution model for this archive is specifically designed so that it can survive the loss of any individual contributor, editor, site manager or web site. Hopefully this allows the archive to continue to serve as a repository of Elvish literature for many years to come!