class: center, middle ### W4995 Applied Machine Learning # Neural Networks 04/16/18 Andreas C. Müller ??? The role of neural networks in ML has become increasingly important in recent years. We will only go through some relatively simple variants, and discuss how to implement them. I highly recommend you take a full course on neural networks, though I know they are a bit hard to get into. In particular we will only talk about supervised feed-forward neural networks, both the standard fully connected variants and convolutional neural networks. We'll not discuss recurrent neural networks or LSTMs or anything more complex. FIXME needs wayyy more polish! FIXME tf.learn is deprecated (now in core or keras?) --- # History - Nearly everything we talk about today existed ~1990 - What changed? – More data -- – Faster computers (GPUs) -- – Some improvements: - relu - Drop-out - adam - batch-normalization - residual networks ??? For some reason, whenever anyone talks about neural networks, they also talk about history, so here's a very brief history of neural nets. While there was a big boom in use of neural nets, say in the last 9 years, many of the methods are actually from the 1990s, so much older than random forests of SVMs. There are two things that people say fundamentally changed the usefullness of neural nets: more data, and computers fast enough to process that data, in particular using GPUs. Actually, neural nets were kind of successful in the 1990s already, Yann LeCun's convolutional networks were used to reach checks automatically in ATMs. That worked well because for digit recognition we had enough traning data becaus the variety was "small" enough. For natural images or audio, the variety in the data is much much larger, and so we need much larger datasets to learn neural networks from those. And using these larger datasets was not possible to collect in the 90, and not feasible to learn on without fast GPUs. For other datasets, like tabular data as we saw it before in this class, which have been the most popular domain of machine learning for a long time, there is often not enough data available for neural nets to work, and so people were very skeptical of them for a long time. Because neural networks were so successful recently, there has been a giant amount of research around them, and that resulted in many important improvements like the use or relu units, drop out, adam, batch normalization and residual networks. We'll talk about these improvements today and next time as well. The dramatic shift that we've seen is mostly due to the availability of data and processing power, though. --- #Logistic regression drawn as neural net .center[ ![:scale 40%](images/log_reg_nn.png) ] ??? Before I introduce you to neural networks, I want to introduce you to how people often draw neural networks, but drawing a model that you already know, binary logistic regression, in the same way. This drawing basically only encodes the prediction process, not the model building or fitting process. Often networks are drawn as circles, which basically represent numbers. So here, I drew a four-dimensional input vector, x[0] to x[3]. For each input, we drew a little circle representing this number. In binary logistic regression, the output is computed as the inner product of the input vector and a weight vector w, or in other words a weighted sum of the x's, weighted by the ws. So each of these arrows corresponds to weighting the input by an w_i and then they are all added up to the output y. In logistic regression we usually compute the output y as the probability, given by the logistic sigmoid of this weighted sum. This is not drawn but kind of implicit in the picture. I also didn't draw the bias here, which is also added to the final sum. So to summarize, circles mean numbers, and arrows mean products between what's on the origin of the arrow, and a coefficient that's part of the model. And arrows into circles mean sums, and they often imply some non-linear function like the logistic sigmoid. --- #Basic Architecture .center[ ![:scale 50%](images/nn_basic_arch.png) ] `$ h(x) = f(W_1x+b_1) $` `$ o(x) = g(W_2h(x) + b_2) $` ??? So now let's look at what a neural network is. It's very similar to the logistic regression, only applied several times. So here I drew three inputs x, from which we compute weighted sums. But now there is not only a single output, but we compute several intermediate outputs, the hidden units. Each of the hidden units is a weighted sum of the inputs, using different weights. Each hidden unit corresponds to an inner product with a weight vector, so all together they correspond to multiplying the input by a matrix, here a 3 by 4 matrix. We also add a bias for each of the hidden units, so a vector of dimension 4 for all of them. Then, we basically repeat the process and compute again weighted sums of the hidden units, to arrive at the outputs. Here this would correspond to multiplying by a 4 by 2 matrix, and adding a vector of dimension 2. Then we could apply for example a logistic sigmoid or softmax to get a classification output. So we basically do two matrix multiplications. If that was all, we could simplify this by just multiplying the matrices together into a single matrix, and we would just have a linear model. But the interesting part is that in the hidden layer, after we compute the weighted sum, we apply a non-linear function, often called activation function or just nonlinearity. That is what makes this whole function non-linear, and allows us to express much more interesting relationships. You can think of this as doing logistic regression with learning non-linear basis functions. The process is written here in formulas, we take the input x, multiply with a matrix W, add a bias b, and apply a non-linearity f, to get h. Then we multipy h by another matrix W', add a bias b' and apply a non-linearity g. This looks a bit like the word2vec we had last time, though here it's really very important to have the non-linear activation functions. Wha we want to learn from data are the weights and biases, so in this case a 3x4 matrix, a vector of dim 4, a 2x4 matrix and a vector of dim 2. Each of these steps of computation is usually called a layer. Here we have an input layer, one hidden layer, and an output layer. The hidden layer is called hidden because the computation is not actually part of the result, it's just internal to the algorithm. Though I'm drawing all these things in a similar way, don't confuse them with graphical models, as I drew them for latent dirichlet allocation. All these nodes here are completely deterministic functions, and the graph just illustrates very simple computations. --- # More layers .center[ ![:scale 60%](images/nn_manylayers.png) ] ??? - Hidden layers usually all have the same non-linear function, weights are different for each layer. - Many layers → “deep learning”. - This is called a multilayer perceptron, feed-forward neural network, vanilla feed-forward neural network. - For regression usually single output neuron with linear activation. - For classification one-hot-encoding of classes, n_classes many output variables with softmax. We can have arbitrary many layers in a neural network, and more layers or more units allow to express more complex functions. And the term deep-learning is referring to neural nets with many hidden layers. This type of network is called a multilayer perceptron, basically because it has more than one layer of computation. For the output, it functions similar to linear models. You can do binary classification with a single output, you can do multi-class classification with a softmax like in multinomial logistic regression, or you can have just a single output for regression. All of the hidden layers usually have the same non-linear function f, but that's not usually the same as the output function. --- #Nonlinear activation function .center[ ![:scale 65%](images/nonlin_fn.png) ] ??? The two standard choices for the non-linear activation function are shown here, either the tanh, which is the more traditional choice, or the rectified linear unit or relu, which is more commonly used recently. Tanh basically squashes everything between -inf and +inf to -1 and 1 and saturates towards the infinities. The rectified linear unit just is constant zero for all negative numbers, and then the identity. One of the reasons given for preferring the relu unit is that the gradient of tanh is very small in most places, which makes it hard to optimize. --- #Supervised Neural Networks - Non-linear models for classification and regression - Work well for very large datasets - Non-convex optimization - Notoriously slow to train – need for GPUs - Use dot products etc require preprocessing, → similar to SVM or linear models, unlike trees - MANY variants (Convolutional nets, Gated Recurrent neural networks, Long-Short-Term Memory, recursive neural networks, variational autoencoders, generative adverserial networks, neural turing machines...) ??? I want to give you a brief overview of what these models are for before we dive into more details. These are non-linear models that can be used for classification and regression. They can also be used for much more, but we'll not talk about this in this class. They are what's called universal approximators, so they can model, i.e. overfit any function, like trees or RBF Kernel SVMs. They work particularly well for very large datsets, usually with at least tens of thousands of samples, or even millions of examples. They require solving a non-convex optimization problem, so the solution is dependent on initialization and the method of optimization you choose. They are notoriously slow to traing compared to many other models, requiring GPUs. There is alot of fast implementations of neural networks on GPUs out there, but scikit-learn doesn't contain any. We'll use scikit-learn a little bit for illustration purposes, but you probably don't want to use it on any real problem. We'll discuss some other libraries that you can use instead, though, in particular tensorflow and keras. You can run these on your laptop, but to really get the benefit of GPUs you need to have the right hardware, so you can either use a cluster or GPU cloud resources or maybe your gaming PC with an Nvidia card. State of the art models in computer vision and audio take days or even weeks to train, often on multiple GPUs. In a sense, neural networks are quite related to linear models, as we'll see in a bit, working also with dot products. So similar to those, you need to preprocess your data to be continuous and scaled. Neural networks, probably because of the non-convex optimization, are actually much more sensitive to scaling than linear models in practice. And finally, as I said earier, there are many many different variants of this. Neural networks, or deep learning, is really an umbrella term that describes a large number of different architectures and algorithms. The things that we'll talk about first are often called vanilla neural networks, or multilayer perceptron. And the zoo of neural network types is growing all the time, given the amount of research in that area. The only other type we'll cover is convolutional neural nets, which we'll cover next time. Other common types include recurrent neural networks like LSTMs, there's recursive neural networks, GANs that are all the rage because they can generate nice faces and cats and photos from drawings, neural turing machines that can learn algorithms, and FIXME of course deep reinforcement learning that can play better go than any human. --- # Training Objective `$$ h(x) = f(W_1x+b_1) $$` `$$ o(x) = g(W_2h(x)+b_2) = g(W_2f(W_1x + b_1) + b_2)$$` -- `$$ \min_{W_1,W_2,b_1,b_2} \sum\limits_{i=1}^N l(y_i,o(x_i)) $$` -- `$$ =\min_{W_1,W_2,b_1,b_2} \sum\limits_{i=1}^N l(y_i,g(W_2f(W_1x+b_1)+b_2)$$` -- - `$l$` Squared loss for regression. Cross-entropy loss for classification ??? So how are we going to learn these parameters, these weights and biases for all the layers? If we did logistic regression, this would be relatively simple. We know it's a convex optimization problem, to optimize the log-loss, so we can just run any optimizer, and they'll all come to the same result. For the neural network it's a bit more tricky. We can still write down the objective. So let's say we have a single hidden layer, then the hidden layer is x multiplied by W with bias b added, and then a non-linearity f, and the output o(x) is another matrix multiplication, another bias, and the output non-linearity like softmax. If we want to find the parameters W1,w2,b1,b2, we want to do empirical risk minimization, so for classification we want to minimize the cross-entropy loss for classification of the outputs o(x) given the ground thruth y_i over the training set. For regression we'd just use the square loss instead. FIXME why W1/W2 here and before W and W'? We could also add a regularizer, like an L2 penalty on the weights W if we wanted, though that's not necessarily as important in neural networks as in linear models. Generally, this is the same approach as for linear models, only the formula for the output is more complicated now. In particular this objective is not convex, so we can basically not hope to find the global optimum. But we can still try to find "good enough" values for the parameters w and b by running an optimizer. We could use a gradient based optimizer like gradient descent, or newton, or conjugate gradient of lbfgs on this objective and this will yield a local optimum, but not necessarily a global one, and that's basically the best we can do. Because you have to care about this optimization more than for many other models I'll go into a bit more details about how this works. Let me know if anything is unclear. --- #Backpropagation - Need `$ \frac{\partial o(x)}{\partial W_i} $` and `$\frac{\partial o(x)}{\partial b_i}$` `$$ \text{net}(x) := W_1x + b_1 $$` .center[![:scale 70%](images/backprop_eqn.png)] ??? To run an optimizer, we do need to compute the gradients for all our parameters though, and that's a bit non-obious. Luckily there's a simple algorithm to do that, called backpropagation, that is computationally very simple. You probably heard the name backpropagation before, and often people make a big deal out of it, but it is not actually a learning algorithm or anything like that, it's just a nice way to compute the gradients in a neural network. And back propagation is basically just a clever application of the chain rule for derivatives. So let's say we want to get the gradients for the first weight matrix W1, so del o/del w1. If you try to write this down directly from the formula for the network it's a bit gnarly, but using the chain rule we can simplify this a bit. Let's define net(X) as the first hidden layer before the non-linearity. Then we can apply the chain rule (twice) and we see that we can write the gradient as a product of three terms, the input to the first layer, x, the gradient of the non-linearity f, and the gradient of the layer after W1, namely h. So to compute the gradient of the first weight vector, we need the activation/value of the layer before, and the derivative of the activation after. FIXME backpropagation image? FIXME need deriviative of loss, not output (unless square loss kinda) When computing the predictions, we compute all the activations of the layers, and we get an error. So we already have all these values. So to compute the gradients, we can do a single sweep, a backward pass, from the output to the input, computing the derivatives using the chain rule. It's probably educational to go through the details of this once yourself, deriving this starting from the chain rule. But you can also just look it up in the deep learning book I linked to. I don't think it's gonna be instructive if I try to walk you through the algebra. Anyone see a problem with this? In particular the gradient of the non-linearity? --- #But wait! .center[ ![:scale 75%](images/relu_differentiability.png) ] ???  I showed you these non-linearities earlier, the relu and the tanh. But the relu is not actually differentiable. it's differentiable everywhere but at zero. So formally, there is no gradient, and we can't do gradient descent. We can do what's called "subgradient" descent, though, which only requires a subgradient. At every point where there's a gradient, we just use the gradient, and if you hit the zero, you can actually pick any gradient that is "below the function" here; any tangent direction is fine. But in reality, you're never going to hit the zero, computing with floating point numbers, so we really don't have to worry about it. And just to point this out again, backpropagation is not an optimization algorithm, it's a way to compute gradients. We still need to think about what optimizer to use to actually find the minimum given the gradients. So how could we do that? Gradient descent for example(FIXME gave answer earlier) --- class: compact #Optimizing W, b Batch `$$ W_i \leftarrow W_i - \eta\sum\limits_{j=1}^N \frac{\partial l(x_j,y_j)}{\partial W_i} $$`
-- Online/Stochastic `$$ W_i \leftarrow W_i - \eta\frac{\partial l(x_j,y_j)}{\partial W_i}$$`
-- Minibatch `$$ W_i \leftarrow W_i - \eta\sum\limits_{j=k}^{k+m} \frac{\partial l(x_j,y_j)}{\partial W_i}$$` ??? So doing standard gradient descent, we would update a weight matrix W_i but using the old W_i and taking a gradient step, so subtracting the gradient of the loss wrt the paramters, summed over the whole training set, times some learning rate. The problem with this is that it's quite slow. Computing all these gradients means that we need to pass all the examples forward through the network, make predictions, and then do a backward pass with backpropagation. That's a lot of matrix multiplications to do a single gradient step, in particular given that we want to do this for very large datasets. So what we can do to speed this up is doing a stochastic approximation, as we already saw for linear models, doing stochastic gradient descent aka online gradient descent. Here, you pick a sample at random, compute the gradient just considering that sample, and then update the parameter. So you update the weights much more often, but you have a much less stable estimate of the gradient. In practice, we often just iterate through the data instead of picking a sample at random. And as with linear models, this is much faster than doing full batches for large datasets. However, it's less stable, and also it doesn't necessarily use the hardware in the best way. So we can do a compromise in where we look at mini-batches of size k, usually something like 64 or 512. So we look at k samples, compute the gradients, average them, and update the weights. That allows us to update much more often than looking at the whole dataset, while still having a more stable gradient, and better being able to use the parallel computing capabilities of modern CPUs and GPUs. This is what's used in practice basically always. The reason why this is faster is basically that doing a matrix-matrix multiplication is faster than doing a bunch of matrix-vector operations. In principle we could also be using smarter optimization methods, like second order methods or LBFGS, but these are often not very effective on these large non-convex problems. One, called levenberg-marquardt is actually a possibility, but it's not really used these days. --- class:spacious # Learning Heuristics - Constant `$\eta$` not good - Can decrease `$\eta$` - Better: adaptive `$\eta$` for each entry if W_i - State-of-the-art: adam (with magic numbers) - https://arxiv.org/pdf/1412.6980.pdf - http://sebastianruder.com/optimizing-gradient-descent/ ??? As with linear models, tuning the learning rate is a major issue here, so finding a good value of eta. Actually, having a constant learning rate during the whole learning process is not good. Instead, we want to make bigger steps in the beginning and smaller steps in the end, so that's what people used for many years. Even better is to have a different learning rate for each parameter that we're tuning, based on past gradient steps. There's many heuristics for that, and it's somewhat related to diagonal approximations of second order methods. There's adagrad, adadelta, rmsprop and may more. When I first started doing neural nets, I actually used something similar, Rprop, from the 90s. Arguably the state of the art for these per-parameter adaptive learning rates is adam. It has some magic numbers in it but it seems to work well in practice. Rmsprop is also used by some. In addition to the speed of convergence, there's the addition issue that you will get different solutions depending on how you pick the learning rates, as it's a non-convex problem. While there is a whole lot of literature on this topic, it's really hard to do actual theory about this, as it's fundamentally impossible to actually find a global optimum. So nearly all of these strategies are heuristics, that have just proven well to work in practice. --- class:spacious # Picking Optimization Algorithms - Small dataset: off the shelf like l-bfgs - Big dataset: adam / rmsprop - Have time & nerve: tune the schedule ??? So for large datasets, something like adam or rmsprop is probably a good idea. However, if you have a very small datasets, you might just try an off-the-shelf solver like lbfgs. Lbfgs basically uses an estimate of the hessian and is originally meant for convex problems, but it also works reasonably well for non-convex problems. And if you have time and nerve, you can try tuning a learning rate or learning rate schedule yourself, and that can give better results than using one of the heurstics, but only after putting in some effort. One other commonly used strategy is using a constant learning rate for all weights, and half it once learning slows down. These are basically the options that scikit-learn gives you, with the default being adam. For some of the toy datasets we'll use lbfgs instead, which is more likely to give good results if it's feasible to run a large number of iterations. So let's start using these models now, for now with scikit-learn. --- class: middle # Neural Nets in Practice --- #Neural Nets with sklearn .center[ ![:scale 45%](images/nn_sklearn.png) ] .smaller[ ```python mlp = MLPClassifier(solver='lbfgs', random_state=0).fit(X_train, y_train) print(mlp.score(X_train, y_train)) print(mlp.score(X_test, y_test)) ``` ``` 1.0 0.88 ``` ] ??? So lets start with some toy data. Here's my favorite two moons dataset. - Don’t user sklearn for anything but toy problems in neural nets. --- #Random State .center[ ![:scale 75%](images/random_state.png) ] ??? This net is also way over capacity and can overfit in many ways. Regularization might make it less dependent on initialization. --- # Hidden Layer Size .smaller[ ```python mlp = MLPClassifier(solver='lbfgs', hidden_layer_size=(5,), random_state=10) mlp.fit(X_train, y_train) print(mlp.score(X_train, y_train)) print(mlp.score(X_test, y_test)) ``` ``` 0.93 0.82 ``` ] .center[ ![:scale 50%](images/hidden_layer_size.png) ] ??? By default in scikit-learn, it has a single hidden layer with 100 units. Hidden layer size is a tuple. The number of entries gives you the number of hidden layers, and each integer gives you the size of the layers. So here, this one has a single hidden layer of size 5. If I didn't put the comma here, it will give me an error, because then it'll just pass 5, not the tuple of length 1 with a 5 in it. Each unit corresponds to a different part of this line segment. And if you add more units you get more smooth line segments. --- # Hidden Layer Size .smaller[ ```python mlp = MLPClassifier(solver='lbfgs', hidden_layer_sizes=(10, 10, 10), random_state=0) mlp.fit(X_train, y_train) print(mlp.score(X_train, y_train)) print(mlp.score(X_test, y_test)) ``` ``` 0.97 0.84 ``` ] .center[ ![:scale 48%](images/hidden_layer_size_2.png) ] ??? Instead of the layer wide, we can add more hidden layers. So here, I created 3 hidden layers each of size 10. This is one of the main ways to control complexity in the model. The question is, does each hidden layer correspond to some representation of the data or a learned feature? Yeah, that definitely makes sense to think of the activations as features. But these are learned in a very supervised way, we're learning these to classify. So basically, the idea is that the first layer will be more sort of related to what did the input look like, whereas the last layer will look more like which class does this represent.  - Using tanh we get smoother boundaries - Here actually it fits the data better. - It might be that relu doesn’t work that well with l-bfgs or with using these very small hidden layer sizes. - For large networks, relu is definitely preferred. --- # Regression .center[ ![:scale 55%](images/regression_plot.png) ] .smaller[ ```python from sklearn.neural_network import MLPRegressor mlp_relu = MLPRegressor(solver="lbfgs").fit(X, y) mlp_tanh = MLPRegressor(solver="lbfgs", activation='tanh').fit(X, y) ```] ??? We can use the same neural networks for regression. We can do this relu or tanh. Relu gives more line segments, and a little bit more abrupt than the tanH. Tuning the number of hidden layers in the hidden layer sizes is kind of tricky. I want to give you some intuition about how you might do that. So one thing definitely to think about is representing the input. So if I have a 1000-dimensional vector, and my first hidden layer size is 2 that means the first layer would need to compress everything in my 1000-dimensional vector into a 2-dimensional space. And if I tried to do this, it will probably lose most of the information. So if you want to do classification, you usually don't want to compress down your input space too quickly. --- class:spacious # Complexity Control - Number of parameters - Regularization - Early Stopping - (drop-out) ??? These are the main ways to control complexity. Early stopping means while you're doing gradient descent, you're looking at a validation set, and you stop, when you start to overfit. This is a very weird way to control complexity from a machine learning point of view because it's a little bit unclear what you're optimizing, but it has been proven very successful in practice. Basically, you don't try to find the optimum, you just do gradient descent and get closer and closer to the optimum, then you try to detect when are you overfitting and once you're overfitting, you stop learning. FIXME number of parameters calculation graph! --- #Grid-Searching Neural Nets .smaller[ ```python from sklearn.datasets import load_breast_cancer data = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split( data.data, data.target, stratify=data.target, random_state=0) from sklearn.model_selection import GridSearchCV pipe = make_pipeline(StandardScaler(), MLPClassifier(solver="lbfgs", random_state=1)) param_grid = {'mlpclassifier__alpha': np.logspace(-3, 3, 7)} grid = GridSearchCV(pipe, param_grid, cv=5) ```] .smaller[ ```python results = pd.DataFrame(grid.cv_results_) res = results.pivot_table(index="param_mlpclassifier__alpha", values=["mean_test_score", "mean_train_score"]) res ```] ??? --- .center[![:scale 50%](images/gridsearch_table.png)] .center[![:scale 45%](images/gridsearch_plot.png)] ??? This is the breast cancer dataset. In orange is the training score and in blue is the validation error. If the alpha value is very small, you overfit perfectly. And if you increase it, then it worsens. But generally, having a simpler model is probably preferable. You can also do a grid search for the hidden layer sizes. --- #Searching hidden layer sizes .smaller[ ```python from sklearn.model_selection import GridSearchCV pipe = make_pipeline(StandardScaler(), MLPClassifier(solver="lbfgs" ,random_state=1)) param_grid = {'mlpclassifier__hidden_layer_sizes': [(10,), (50,), (100,), (500,), (10, 10), (50, 50), (100, 100), (500, 500)] } grid = GridSearchCV(pipe, param_grid, cv=5) grid.fit(X_train, y_train) ```] .center[![:scale 40%](images/search_hidden_layers_plot.png)] ??? Ideally, you can do both at once. This is mostly to illustrate how you can grid search over the different hidden layer sizes. If you have a big dataset running this will probably take too long. --- class:center,middle #Getting Flexible and Scaling Up ??? Now we'll look at neural nets beyond scikit-learn. There are two main motivations for this: scaling to larger datasets and larger networks using GPUs, and having more flexible ways to create the neural network architectures. If you want to get serious about neural nets, you are likely to include some modifications to the standard network. So how could you go about doing that? --- class:spacious # Write your own neural networks .smaller[ ```python class NeuralNetwork(object): def __init__(self): # initialize coefficients and biases pass def forward(self, x): activation = x for coef, bias in zip(self.coef_, self.bias_): activation = self.nonlinearity(np.dot(activation, coef) + bias) return activation def backward(self, x): # compute gradient of stuff in forward pass pass ```] ??? It’s actually pretty straight-forward to write the prediction functions, or forward pass of a neural network. There is matrix multiplications and nonlinearities. It quickly becomes more complicated when you use some of the tricks we’ll discuss today, but even for this writing down the gradient can be a bit tricky and something people used to get wrong all the time. So they came up with a trick that avoided having to write down the gradients yourself, also known as the backward pass. That trick is autodiff. --- #Autodiff .smaller[ ```python # http://mxnet.io/architecture/program_model.html class array(object) : """Simple Array object that support autodiff.""" def __init__(self, value, name=None): self.value = value if name: self.grad = lambda g : {name : g} def __add__(self, other): assert isinstance(other, int) ret = array(self.value + other) ret.grad = lambda g : self.grad(g) return ret def __mul__(self, other): assert isinstance(other, array) ret = array(self.value * other.value) def grad(g): x = self.grad(g * other.value) x.update(other.grad(g * self.value)) return x ret.grad = grad return ret ```] ??? Here is a toy implementation of the idea behind autodiff. It’s a class called array with some operations such as addition of integer and multiplication with other arrays. It also has a method that returns the gradient called grad. The gradient of the array is just the identity function. The trick is what happens with the addition and multiplication. If you add something to an array or you multiply two arrays, the result again is an array, and has again a gradient. The product actually has two gradients, one for each array involved. The magic here is that while we are doing some computation, we are keep track of that computation and building up a graph of how to compute the gradient of it. --- .smaller[ ```python a = array(np.array([1, 2]), 'a') b = array(np.array([3, 4]), 'b') c = b * a d = c + 1 print(d.value) print(d.grad(1)) ```] ``` [4 9] {'b': array([1, 2]), 'a': array([3, 4])} ``` ??? On the right you can see the result of adding two arrays and then computing the gradient at a particular location. FIXME the gradient of multiplication? Any computation in the neural network is a simple operation like a matrix multiplication, addition or nonlinearity. If we write down the derivative of each of these, we can keep track of our computation and automatically get the derivative. It’s really easy to implement but really helpful. Keep in mind that we actually hard-code the derivative for each operation, there is no symbolic differentiation involved. --- --- # GPU Support .center[ ![:scale 45%](images/gpu_support.png) ] - From http://www.nvidia.com/object/gpu-accelerated-applic ations-tensorflow-benchmarks.html - Take with a grain of salt. ??? An important limitation of GPUs is that they usually have much less memory than the RAM, and memory copies between RAM and GPU are somewhat expensive. --- #Computation Graph .center[ ![:scale 100%](images/computation_graph.png) ] ??? Autodiff doesn’t solve all of the problems, though. Depending on which derivations you need to compute, you need to store different intermediate results (the net activation in backprob for example). Given the limited amount of memory available, it’s important to know what to store and what can be discarded. That requires an end-to-end view of the computation, which can be summarized as a graph. Then you can use knowledge about the computation graph to decide what results to cache, what results to throw away and when to communicate between CPU and GPU. Having a representation of the graph also helps with visual debugging and understanding your network structure. The computation graph is more complex than the network graph because it includes intermediate results and gradient computations. --- # All I want from a deep learning framework - Autodiff - GPU support - Optimization and inspection of computation graph - on-the-fly generation of the graph? - distribution over cluster? - Choices: – TensorFlow – Theano – Torch (lua) ??? So create deep learning model efficiently, I need support for auto diff, computation on a GPGPU, and optimization and inspection of the computation graph. There is some more advanced features that can come in handy for research, like on-the-fly generation of computation graphs, and distributing the network over multiple GPUs or over a cluster. At least the first three are all provided by the TensorFlow, Theano and Torch frameworks, which are the most established deep learning frameworks. These don’t provide deep learning models, they are infrastructure, more like numpy on steroids than sklearn. Theano was an early deep learning library for python, but I think it has become less relevant since tensorflow got released. --- #Deep Learning Libraries - tf.learn (Tensorflow) - Keras (Tensorflow, Theano) - Lasagna (Theano) - Torch.nn / PyTorch (torch) - Chainer (chainer) - MXNet (MXNet) - Also see: http://mxnet.io/architecture/program_model.html ??? Then there are actual deep learning libraries that provide higher level interfaces built on top of this infrastructure. There are a lot of these right now given the deep learning hype, I want to point out a couple. There is tf.learn, a high-level interface to tensorflow, including a scikit-learn compatible API. There’s keras, which supports both Tensorflow and theano, there’s lasagna, which I think has seen less activity recently, and torch.nn (lua) and pytorch building on top of the torch framework. Then there are two projects that are deep learning libraries but that also come with their own framework underneath, chainer and mxnet. I think right now Keras with tensorflow is the most commonly used one, and I want to go into those two a bit more. But these all have their pros and cons. --- #Quick look at TensorFlow - “down to the metal” - don’t use for everyday tasks - Three steps for learning: – Build the computation graph (using array operations and functions etc) – Create an Optimizer (gradient descent, adam, …) attached to the graph. – Run the actual computation. ??? If you want to do neural network research, if you want to build new kinds of neural network that no one ever thought about, then using TensorFlow might be good. You can use TensorFlow for things that are are not neural networks, you can just do like find elements simulations, or you can run a linear model or some matrix factorization. If you have a complex computation graph that you want to optimize or if you want to compute gradients, then TensorFlow can help you. If you want to do this for actual learning, there are basically three steps. The first step is to build a computation graph. The second step is to create an optimizer and tell the optimizer to optimize the graph. Third, then you want to run the actual computation. Here, we are decoupling the building of the computation graph, and the actual computation. --- .center[ ![:scale 75%](images/tensor_flow_basics.png) ] ??? This is linear regression in TensorFlow. We have a very simple 1D regression tasks that I created with Numpy. --- # Great Resources! - https://www.tensorflow.org/versions/r0.10/tutorials/ - http://playground.tensorflow.org - https://www.tensorflow.org/versions/r0.10/get_star ted/basic_usage - https://www.tensorflow.org/versions/r0.10/tutorials /mnist/beginners/ - Note: tf.learn is now officially tf.contrib.learn - Tensorboard web interface ??? --- class: middle # Questions ?


HTML5 Template
All website template is released under a Creative Commons Attribution 2.5 License
We request you retain the full copyright notice below including the link to www.flash-templates-today.com. This not only gives respect to the large amount of time given freely by the developers but also helps build interest, traffic and use of our free and paid designs. If you cannot (for good reason) retain the full copyright we request you at least leave in place the Website Templates line, with Website Templates linked to www.flash-templates-today.com. If you refuse to include even this then support may be affected.
You are allowed to use this design only if you agree to the following conditions:
- You can not remove copyright notice from any our template without our permission.
- If you modify any our template it still should contain copyright because it is based on our work.
- You may copy, distribute, modify, etc. any our template as long as link to our website remains untouched.
Testimonials about our templates
- Thank you for your professional template! It worked perfectly for what I needed and I was able to get my site up and running within a couple hours. The photos are beautiful and colors complimentary and everything works great. Thanks again!
Lily from www.360environmental.net - We us your template on www.bhmaat.nl. Our vistors like your design very much! So do we. With our create design we could redesign the site in a couple of hours! The code is clean, well documented and easy to use. Thank you !!!
Bas Jobsen


Pomodoro
Statistics
Settings
title
remain time
elapsed time
start
Settings
×
Focus
Break
LongBreak
Goal per Day
Cycle


Task
New
∙
Code...
Prefix
Configuration Layers
Input
∙
Task Items
∙
Output
|
Foreign
{VARIABLES}
Set...
Actions
Validate
∙
Run
locally
via TeamCity
Input Adapters
Control Flow $DIRECTIVES
LET
Create a list variable from data stream
ITER
Iterate through a list variable
END
End loop or conditional
IF
Conditional operator
ELSE
Alternate branch of conditional or empty list loop
METRICS
Calculate data stream metrics
Operations
Output Adapters
Foreign Layers
New Layer
Add...


{%extends 'myhood/base.html'%} {% load static %} {% block content %}
{{myhood.hood.location}}
{{myhood.hood.description}}
Kindly update your hood
No available posts
{% endif %}{{biz.name}}
{{biz.description}}
{{post.title}}
No registered businesses in your hood
{%endfor%}{{hos.name}}
{{hos.description}}
No registered hospital in your hood
{% endfor %}Update your Profile to see your hood details
If your hood appears below click to update your profile
If your hood is not registered. Register below


|
Hey, please get me out of here. This place stresses me out so much. All this noise and the energy here makes me kind of lose it. I just want a nice place where I can relax and spend the rest of my life in. I don't want commotion. I want a nice couple of adults, no kids, and a quiet home with some room to play. I swear, once I'm out of this crazy kennel, I'm a completely different Harley. I much prefer the mellow, take a nap in the middle of the afternoon and go to bed early lifestyle. I don't like this place. Can I go with you? I'll make it worth it, trust me. I'll be the best dog you've ever had.
|
|


Building the Source
Introduction
This document provides detailed information for developers that wish to compile and make changes to the Openfire source code.
For additional developer resources, please visit: https://www.igniterealtime.org.
The Openfire build process is based on Apache Maven. Visit the Maven website for more information.
This documentation is divided into three sections:
Get the Openfire Source
You can get the Openfire source code by downloading a source distribution or by checking out the source code from the Openfire Github repository. Instructions for both options can be found on the source page.
Setup Your Environment
Getting your machine ready for development requires a few steps. Wherever possible, instructions are provided for both Unix/Linux and Windows users.
Configure Java for Openfire
Java 11 (JDK 11) must be installed and setup on your machine. To test the installation, open a shell in a Unix or a command prompt in Windows. Check your version of Java with "java -version" -- it must version 11 or greater.
Important! -- the Openfire build tool needs to know where Java is installed on your system. You must configure the "JAVA_HOME" environment variable to point to the correct directory. Instructions on how to set this variable for various platforms are as follows:
Unix/Linux
- Edit the ".profile" file in your home directory (or corresponding file for your shell).
- Set the JAVA_HOME environment variable by adding the following line to the file:
export JAVA_HOME=/usr/local/jdk11
The value "/usr/local/jdk11" should be replaced with your actual Java directory. Be sure there are no spaces after the end of the directory name. Do not add an extra slash after the directory name. - Save changes to the file and then "source" it:
source .profile
The JAVA_HOME variable should now be configured correctly.
Microsoft Windows
- Navigate to your desktop and right click on "My Computer"; choose properties.
- Select the "Advanced" tab and click on the "Environment Variables" button.
- Click the "New..." button in the System variables section. Enter the variable name "JAVA_HOME" and set the variable value to the full path of your Java installation. For example, "c:\jdk11". Be sure to not add an extra slash to the end of the directory name.
- Click "OK" in all the menus to accept the changes.
- Close any open command prompt windows. The next time you open a command prompt, the "JAVA_HOME" variable will be set correctly.
Install the Maven Build Tool
The Openfire build process uses Maven, so that tool must be installed and configured on your computer. First download Maven from: https://maven.apache.org. Next, follow the usage instructions.
Test building with Maven
Navigate into the root directory of this distribution named via the command-line. In that directory, invoke the build tool to compile the Openfire source code:
mvn compile
If the build tool is invoked correctly and Openfire compiles, you've correctly configured Maven and your copy of the Openfire source distribution.
Build Phases
Openfire conforms to the standard Maven build process. For a full list of the commands please review the Apache Maven documentation. For more complete help on several commands, read the documentation below.
To execute a build phase, type mvn "phase"
where "phase" is one of the keywords listed below:
Note that you can combine several phases, for example: mvn clean package
.
When a phase is given, Maven will execute every phase in the sequence up to and
including the one defined. For example, when the 'package' phase is executed, the
'compile' and 'test' phases are also executed (but the 'clean' phase is not, unless
specified explicitly). Please refer to the Maven documentation for more details.
clean
Cleans all artifacts of the build process.
compile
Builds Openfire components into the target
directory of each module.
test
Builds Openfire components, and runs all unit tests.
package
Builds Openfire components, runs all unit tests, and creates a distributable package
in the distribution
module. You can then launch Openfire using the scripts in
distribution/target/distribution-base/bin
.


Yes you need Java JRE 1.7. If you don't have the right version you will bea asked to install the correct version.
Try refreshing the browser
Javafx doesn't seem to run in Chrom on a Mac. Give it a try in Safare or Firefox.


Privacy Policy
PURPOSE
Ardint LLC (collectively, “Ardint,” the “Company,” “we” or “us”) are sensitive to privacy issues, and it is important to us to protect the information provided to us. Accordingly, Ardint provides this privacy and information practices policy to inform you about our online information
SCOPE
This Privacy Policy applies to Personal Information that is Processed by Ardint in the course of our business, including the Fibro Friend Alexa Skill (together with any and all future websites operated by or on behalf of Ardint, the “Sites”). All individuals whose responsibilities include the Processing of Personal Information on behalf of Ardint
are expected to protect that data by adherence to this Privacy Policy. Ardint complies with the requirements of the EU-U.S. Privacy Shield Framework and the Swiss-U.S. Privacy Shield Framework, as set forth by the U.S. Department of Commerce and the Federal Trade Commission (“FTC”), regarding the collection, use and retention of Personal Information from the European Economic Area and Switzerland to the United States, respectively (collectively “Privacy Shield”). Additionally, Ardint may protect your data through other legally-valid methods, including international data transfer agreements.
TRANSPARENCY/NOTICE–WHAT PERSONAL INFORMATION WE COLLECT AND HOW WE USE IT
The types of Personal Information we may collect (directly from you or from Third Party-sources) and our privacy practices depend on the nature of the relationship you have with Ardint and the requirements of applicable law. We endeavor to collect information only relevant for the purposes of Processing. Below are the legal bases and some of the ways we collect information and how we use it.
Individuals
Ardint collects Personal Information regarding its current, prospective and former clients, customers, visitors and guests (collectively “Individuals”). The data we collect from Individuals includes information such as title, name, address, phone number, email address, user name, answer to a security question and password, and credit card and other financial information related to payments for services or goods. We may also collect demographic information
you choose to provide, such as your business or company information, professional experiences, educational background, nationality, ethnic origin, age, gender, interests, preferences and favorites. We acquire, hold, use and Process Personal Information about Individuals for a variety of business purposes including to:
- generally manage Individual information and accounts;
- respond to questions, comments and requests;
- provide access to certain areas and features of the Ardint Skills and Sites;
- ensure internal quality control;
- verify Individual identity;
- enable Individuals to register for events or participate in webinars;
- communicate about Individual account and activities on WCG’s Sites and systems
- tailor content, advertisements and offers we serve to Individuals;
- process payment for products or services purchased;
- develop new products, processes and services;
- notify you about offers, products and services that may be of interest to you;
- and for purposes disclosed at the time that Individuals provide Personal Information or otherwise with consent.


The pyramids of Giza were royal tombs built for three different pharaohs. The northernmost and oldest pyramid of the group was built for Khufu (Greek: Cheops), the second king of the 4th dynasty. Called the Great Pyramid, it is the largest of the three.
One of the most famous archaeological sites in the world, this is a royal burial ground, with exquisitely decorated tombs for the pharaohs who ruled Egypt between 1539 and 1075 BC. There are over 60 tombs in this small area,
The Giftun Islands are two islands in the Red Sea near Hurghada in Egypt. Giftun Kebir or Big Giftun is located further west and closer to Hurghada. Giftun Soraya or Little Giftun is further east.
Prices start from 7000 USD
Click here to book your spot


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
An easy-peasy coffee cake that makes a great treat for Mother's Day.
Equipment and preparation: You will need two loose-bottomed 18cm/7in sandwich tins.
Preheat the oven to 180C/160C Fan/Gas 4. Lightly butter two loose-bottomed 18cm/7in sandwich tins and line the bases with baking paper.
Put the butter, sugar, eggs, flour, baking powder, walnuts and coffee essence in a large mixing bowl and beat together (using an electric hand whisk if you have one) until well combined and smooth.
Divide the mixture evenly between the tins. Level the surface using a spatula or the back of a spoon.
Bake for 20–25 minutes, or until an inserted skewer comes out clean. Leave the cakes to cool in the tins for 5 minutes, then run a small palette knife or rounded butter knife around the edge of the tins and carefully turn the cakes out onto a wire rack. Peel off the paper and leave to cool completely.
For the filling and topping, beat the butter and gradually add the icing sugar. Add the milk and coffee essence and beat until smooth.
Choose the cake with the best top, then put the other cake top-down onto a serving plate and spread with half the coffee icing. Sandwich together with the other half. Ice the top of the cake and decorate with the walnut pieces to serve.


Expat Journal
Home
About
Share your experiences online, interact with new people, and explore other's experiences!
Login
Register


Upgrades
The upgrades below are available to add to your wash individually if the wash level you chose doesn't already include it.
---
layout: default
title: Car Wash Menu - Prices and Services
navigation_weight: 2
navname: Wash Menu
---
The upgrades below are available to add to your wash individually if the wash level you chose doesn't already include it.


OpenAFP
Contents
Index
OpenAFP.Records.AFP.PGD
Synopsis
data
PGD
=
PGD
{
pgd_Type
:: !
N3
pgd_
:: !
N3
pgd_XUnitBase
:: !
N1
pgd_YUnitBase
:: !
N1
pgd_XLUnitsperUnitBase
:: !
N2
pgd_YLUnitsperUnitBase
:: !
N2
pgd_Reserved1
:: !
N1
pgd_XPageSize
:: !
N2
pgd_Reserved2
:: !
N1
pgd_YPageSize
:: !
N2
pgd__
:: !
NStr
}
Produced by
Haddock
version ADDOCK_VERSION


Up: I/O
Next: File Consistency
Previous: Matching Data Representations
Up: I/O
Next: File Consistency
Previous: Matching Data Representations
Return to MPI-2 Standard Index
Return to MPI 1.1 Standard Index
Return to MPI Forum Home Page
MPI-2.0 of July 18, 1997
HTML Generated on September 10, 2001


guillermo{at}guerreroibarra{dot}com
Follow me on github: https://github.com/ryanfox1985
February 17th, 2016
$ vagrant [command]
More at vagrantup cli
Vagrant.configure (2) do |config|
config.vm.box = 'ubuntu/trusty64'
config.ssh.forward_agent = true
config.vm.network 'forwarded_port', :guest => 80, :host => 8000
config.vm.provider 'virtualbox' do |vb|
vb.memory = '1024'
vb.gui = false
end
end
config.vm.provision 'shell', inline: <<-SHELL
sudo apt−get update
sudo apt−get install −y apache2
SHELL
# Setup when the VM is first created
app.vm.provision 'shell', path: 'vagrant/setup.sh'
# This script is running every time we start the VM.
app.vm.provision 'shell', run: 'always', path: 'vagrant/start.sh'
Vagrant.configure(2) do |config|
...
# Enable Berkshelf support
config.berkshelf.enabled = true
config.berkshelf.berksfile_path = './Berksfile'
...
end
source "https://supermarket.getchef.com"
cookbook 'apt'
cookbook 'git'
cookbook 'build-essential'
cookbook 'nodejs'
cookbook 'mysql'
cookbook 'rvm'
cookbook 'openssl'
cookbook 'app', path: './site-cookbooks/app'
...
config.vm.provision :chef_solo do |chef|
chef.add recipe 'apt'
chef.add recipe 'build−essential'
chef.add recipe 'git'
chef.add recipe 'nodejs'
chef.add recipe 'app::mysql'
end
Note: Recipe order is important.
site-cookbooks/app
attributes
list_of_attributes.rb
recipes
list_of_recipies.rb
templates
defaults_files
Berksfile
metadata.rb
mysql_service 'default' do
port '3306'
version '5.5'
initial_root_password 'put_here_a_password'
action :create
end
[Link to github] An example that sets up a Ruby on Rails development box based on Ubuntu with RVM, Ruby 2.1.0, MySQL 5.5.
Coobooks are very unstable.
You need a good computer with Ram.
[Link to github]: A box with Btsync, DYNDNS, SickRage, Couch potato and Deluge
Inspired in Freenas
Vagrant.configure(2) do |config|
...
# Ubuntu
config.vm.box = 'ubuntu/trusty64'
# Install latest docker
config.vm.provision 'docker'
# Setup the containers when the VM is first created
config.vm.provision 'shell', path: 'vagrant/setup.sh'
# Make sure the correct containers are running
# every time we start the VM.
config.vm.provision 'shell', run: 'always', path: 'vagrant/start.sh'
end
# Stop and remove any existing containers
docker stop $(docker ps -a -q)
docker rm $(docker ps -a -q)
# Run and link the containers
docker run -d -v /vagrant/ddclient/etc:/etc/ddclient --name dynamicdns \
ryanfox1985/docker-dynamicdns
docker run -d -p 8888:8888 -v /vagrant/ddclient/etc:/etc/ddclient \
--name sync bittorrent/sync
...
# Commands required to ensure correct docker containers are started when the vm is rebooted.
docker start dynamicdns
docker start sync
docker start sickrage
docker start couchpotato
docker start deluge


Introversion
Speed
Walls
Collisions
Seek Mouse
Racism
Diversity
Introversion
Speed
Walls
Collisions
Seek Mouse
Racism
Diversity
fps
About Project


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object de.fhpotsdam.unfolding.utils.GeneralizationUtils
public class GeneralizationUtils
Provides utility functions to simplify points, paths, and polygons.
| Constructor Summary | |
|---|---|
GeneralizationUtils()
|
| Method Summary | |
|---|---|
protected static float[] |
computeMovingAverage(float[] values,
int np)
Calculates the np-point moving average for some values. |
static java.util.List<processing.core.PVector> |
computeMovingAverage(java.util.List<processing.core.PVector> vertices,
int np)
Calculates the moving average of vertices. |
protected static float |
getSquareDistance(processing.core.PVector p1,
processing.core.PVector p2)
Square distance between 2 points. |
protected static float |
getSquareSegmentDistance(processing.core.PVector p,
processing.core.PVector p1,
processing.core.PVector p2)
Square distance from a point to a segment. |
static java.util.List<processing.core.PVector> |
simplify(java.util.List<processing.core.PVector> points,
float tolerance,
boolean highestQuality)
Simplifies points by using Douglas-Peucker algorithm. |
protected static java.util.List<processing.core.PVector> |
simplifyDouglasPeucker(java.util.List<processing.core.PVector> points,
float sqTolerance)
Simplification using optimized Douglas-Peucker algorithm with recursion elimination. |
protected static java.util.List<processing.core.PVector> |
simplifyRadialDistance(java.util.List<processing.core.PVector> points,
float sqTolerance)
Distance-based simplification. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public GeneralizationUtils()
| Method Detail |
|---|
public static java.util.List<processing.core.PVector> computeMovingAverage(java.util.List<processing.core.PVector> vertices, int np)
Opposite to simplify(List, float, boolean)
this keeps the same amount of vertices, so does not improve
performance, but creates smoother paths. You might want to combine both methods.
vertices
- The vertices to smoothen.np
- The number of points to average over.
protected static float[] computeMovingAverage(float[] values, int np)
np
- number of points to average over.
public static java.util.List<processing.core.PVector> simplify(java.util.List<processing.core.PVector> points, float tolerance, boolean highestQuality)
Location
s due to the tolerance value.
Opposite to computeMovingAverage(List, int)
this reduces the amount of vertices, and thus improves
performance, but may result in still too complex paths. You might want to combine both methods.
Based on Simplify.js by Vladimir Agafonkin. Ported to Java and modified for Unfolding by Till Nagel.
points
- A list of vertices.tolerance
- The amount of simplification (in the same metric as the points).highestQuality
- Whether to exclude distance-based preprocessing step which leads to highest quality simplification but
runs ~10-20 times slower.
protected static float getSquareDistance(processing.core.PVector p1, processing.core.PVector p2)
protected static float getSquareSegmentDistance(processing.core.PVector p, processing.core.PVector p1, processing.core.PVector p2)
protected static java.util.List<processing.core.PVector> simplifyRadialDistance(java.util.List<processing.core.PVector> points, float sqTolerance)
points
- List of vertices.sqTolerance
- The square tolerance value.
protected static java.util.List<processing.core.PVector> simplifyDouglasPeucker(java.util.List<processing.core.PVector> points, float sqTolerance)
points
- List of vertices.sqTolerance
- The square tolerance value.
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Modes
Use the [mode]
property to specify the one of these modes.
Modes:
none
: Default mode (no selection)
delete
: Delete mode (only one list item can be deleted via provided delete button)
-
singleSelect
: Selected item is highlighted but no selection control is visible (only one list
item can be selected)
-
singleSelectLeft
: Left-positioned single selection mode (only one list item can be selected)
-
singleSelectRight
: Right-positioned single selection mode (only one list item can be selected)
multiSelect
: Multi-selection mode (more than one list item can be selected)
None mode
Items cannot be selected but can still use "navigation", which allows click handling on specific items.
Single select mode
One item in the grid list can be selected. Need click on an item to select it. To use the Single select mode, set
[mode]
as singleSelect
.
Note: Whole item with link is clickable. If used within single select mode - selection event will be
emitted first, then navigation event.
Single select left mode
One item in the grid list can be selected. For this, the grid list provides radio buttons on the left side of each
item toolbar. To use the Single select left mode, set [mode]
as singleSelectLeft
.
Single select right mode
One item in the grid list can be selected. For this, the grid list provides radio buttons on the left side of each
item toolbar. To use the Single select right mode, set [mode]
as singleSelectRight
.
Multi select mode
Users can select one or more items. For this, the grid list provides checkboxes on the left side of each item
toolbar. To use the Multi select mode, set [mode]
as multiSelect
.
Delete mode
This places a Delete button on the right side of an item toolbar. To use the Delete mode, set [mode]
as
delete
.
Group
If grouped, a group header is displayed above all items which belong to the corresponding group. The group header is
not interactive. To create grid list group headers use fd-grid-list-group-header component.
States
To apply state, set [state]
as unread|error|locked|draft
.
 To add status
indicator, set [status]
as success|warning|error|neutral
.
More button
The More button loads more items to the front end if not all items have yet been loaded.
The footer can be used to display additional static information relating to the content.
Drag and Drop
Layout
Defines the column layout in the format XLn-Ln-Mn-Sn
where n is the number of columns and can be
different for each size.
Default: XL4-L3-M2-S1
For a base Layout, we can use only 1, 2, 3, 4, 6, or 12 columns in a row.
But it can be more flexible using layoutItemPattern
.
Focusing Item Programmatically
Use focus()
method of the GridListItemComponent
to focus item programmatically.


|
BL3 SDK
0.0.1
Borderlands 3 Class Documentation
|
#include <BL3_OakGame_classes.hpp>
Public Member Functions | |
| void | SetPinata (class AActor *NewPinataActor) |
| void | HandleLevelChanged (int OldLevel, int NewLevel) |
| Public Member Functions inherited from UOakStreamingInteractionEvent | |
| void | EndEventFallback () |
| Public Member Functions inherited from UObject | |
| std::string | GetName () const |
| std::string | GetFullName () const |
| bool | IsA (UClass *cmp) const |
| void | ProcessEvent (class UFunction *function, void *parms) |
| void | ExecuteUbergraph (int EntryPoint) |
Static Public Member Functions | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UOakStreamingInteractionEvent | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UGbxDataAsset | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UDataAsset | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UObject | |
| static FChunkedFixedUObjectArray & | GetGlobalObjects () |
| template<typename T > | |
| static T * | FindObject (const std::string &name) |
| static UClass * | FindClass (const std::string &name) |
| template<typename T > | |
| static T * | GetObjectCasted (std::size_t index) |
| static UClass * | StaticClass () |
Additional Inherited Members | |
| Static Public Attributes inherited from UObject | |
| static FUObjectArray * | GObjects |
| void HandleLevelChanged | ( | int | OldLevel, |
| int | NewLevel | ||
| ) |
| void SetPinata | ( | class AActor * | NewPinataActor | ) |
|
inlinestatic |
| float MaxEventDuration |
| int MaxItemInPoll |
| int MaxSpawnAttempt |
| struct FPollActionInfo NoViewersAction |
| class AActor* PinataActor |
| TSoftObjectPtr<class UClass> PinataClass |
| class UClass* PinataClassRef |
| struct FEnvQueryParams PinataSpawnLocationParams |
| TArray<struct FPollActionInfo> PollAvailableActions |
| struct FText PollEnded |
| struct FText PollSelected |
| struct FText PollStarted |
| float PollTimerDuration |
| unsigned char UnknownData00[0x10] |


Take Five: Food events around the U.S. (November 22)
by CBS NewsCheck out these food events around the country this holiday week:
Bangor, Me.: Maine Harvest Festival (November 23-24)
Enjoy the fall harvest of over 200 Maine farmers, brewers, distillers, and festival food producers, by sampling their extraordinary creations as they "Celebrate Farm Fresh!" at this year's 9th annual Maine Harvest Festival. Culinary students, home cooks and commercial cooks are invited to compete in their "Two Crusted" Apple Pie Contest. At Cross Insurance Center, Bangor.
Chisago City, Minn.: 21st Annual Cheese and Chocolate Weekend (November 23-24)
This weekend, come and sample your way through some great cheese and chocolate wine pairings. Discover which cheeses pair best with which wines, and how to make a simple bite of chocolate shine as a dessert course with wine. At WineHaven Winery and Vineyard, 10020 Deer Garden Lane, Chisago City, Minn.
Yankeetown, Fla.: 38th Annual Yankeetown Seafood Festival (November 23-24)
The festival, held along Riverside Drive in a scenic village about two hours north of Tampa on Florida's Gulf Coast, features food, arts and crafts, as well as live music.
Rosendale, N.Y.: 22nd Annual Pickle Festival (November 24)
Always held the Sunday before Thanksgiving. Features 100 vendors, including 20-25 pickle vendors. Come shop for pickles, food, clothing, jewelry and much more! Register to join their pickling contest, as well as the pickle eating contest, pickle juice drinking contest, and pickle tossing contest.
Watch a pickle cavort around Rosendale, 'cause that's what pickles do:
Plymouth, Mass.: Thanksgiving at Plimoth Plantation (November 28)
Plimoth Plantation is a great place to share that special meal with your family and friends – and with visitors from around the world. Enjoy their Craft Center Buffet (11 a.m. through 4 p.m.), and their Thanksgiving Day Homestyle Buffet (1:30 p.m. and 4 p.m. seatings still available).
Plimouth is also serving up a "Story of Thanksgiving Dinner" buffet-style on Friday, November 29 (12 p.m. and 4:30 p.m. seatings still available). At Plimoth Plantation, 137 Warren Avenue, Plymouth, Mass.


Catching errors when using tolower
29 May 2012When I'm working in R with text data parsed from online opinion forums and social webs (e.g. twitter), I need to do some cleaning and pre-processing such as removing punctuation marks, striping extra white spaces, or converting text to lower case.

Consider the following example. Let's say we have the text from a tweet in an object
called some_text
. When we print the object in the console, we get a warning message
(in red) like this:
So, how can we solve this error? Meet the tryCatch
function! This function will help us to catch possible errors. We'll make a new function
combining tryCatch()
and tolower()
so we can identify any undesirable text
without returning any ugly message and without stopping our programs.
Here's my tryTolower()
function
tryTolower = function(x)
{
# create missing value
# this is where the returned value will be
y = NA
# tryCatch error
try_error = tryCatch(tolower(x), error = function(e) e)
# if not an error
if (!inherits(try_error, "error"))
y = tolower(x)
return(y)
}
Let's test it
Suppose you have a character vector with five elements
# vector with text
text_vector = c(
"Motivation, philosophy and technique in activism. #Assange and #Occupy: http://t.co/89PFkyjh via @RT_com",
"No work today, slept through the classes I wanted at the gym. Now I need to find something to occupy my time \ud83d\udc4d\ud83d\ude09",
"RT @jdavis4100: The Spirit of God and fear never occupy the same space. The presence of one automatically implies the absence of the other...",
"Police given powers to enter homes http://t.co/VXmtfPV5 and tear down anti- #Olympics posters during Games #Occupy #Anonymous #wakeup #fb",
"RT @OccupyWallSt: RT @WSOASP12: I quit my job to join the occupy movement.


Bug summary:
Subscribed channel's ribbon is red instead of blue.
Observed Behavior (a description of what happened with the app):
After subscribing to a channel, going back to Subscriptions page, the added channel appears on screen but with a red ribbon on its top right.
Expected Behavior (a description of what you expected to happen):
The color of the ribbon should be blue.
Steps to Reproduce (the steps to reproduce the problem):
1. Tap on Hamburger menu and tap on Subscriptions.
2. Tap on "Add Podcast".
3. Tap "Search itunes.".
4. Tap on the magnifying glass icon on top right screen to search.
5. Enter "tech" with keyboard and then tap magnifying icon on keyboard.
6. Tap on one of the search results.
7. Tap on "Subscribe".
8. Tap on Back button of app 4 times to go back to Subscriptions page.
Additional information:
Attachments:


In this code:
static reverse_array (ar : array [int]) : void
{
def loop (left, right) {
when ((left : int) < right) {
def tmp = ar[left];
ar[left] = ar[right];
ar[right] = tmp;
loop (left + 1, right - 1)
}
}
loop (0, ar.Length - 1)
}
Q: Is it actually necessary to state "(left : int)"? Couldn't you simply write "when(left
A: Yes, the inferencer can handle this code without type annotation. I guess it is here mainly because our earlier implemenation had problems with it. Maybe it should be removed - it looks a little bit superfluous here, but on the other hand it shows one of the ways of enforcing type of expression. --User:Nazgul 20:14, 22 Jun 2005 (CEST)
I have removed the type enforcement -- it wasn't explaining anything, since there was no mention of it in the description text anyway. --User:Malekith 21:00, 22 Jun 2005 (CEST)
|


About me
I am a theoretical physicist. I am mostly interested in describing quantum many-body systems in cold atom and nuclear physics, particularly using field theory approaches. Some of my specific interests include:
- Bose and Fermi gases
- Quantum mixtures and polarons
- Nuclear and neutron matter
- Functional renormalisation group
- Low-dimensional gases
- Pairing and superfluidity
Contact
Departament de Física Quàntica i Astrofísica
Facultat de Física
Universitat de Barcelona
Martí i Franquès, 1
08028 Barcelona
Spain


Thank you for downloading EPStack!
EPStack is a ready-to-deploy log management solution. This is a scalable solution that offers much more than just log management. It is capable of a variety of inputs and can be used for a wide spectrum of use cases. We have taken the hassle of setup and configuration of ELK stack away so you can concentrate on what’s most important – collecting the data and start analyzing.
Highlights of EPStack


3 references to RemoveJob
System.Management.Automation (3)
engine\remoting\client\JobManager.cs (1)
902
RemoveJob
(job, cmdlet, false);
engine\remoting\commands\ReceiveJob.cs (1)
1421
JobManager.
RemoveJob
(job2, this, false, true);
engine\remoting\commands\RemoveJob.cs (1)
968
job2TypeFound = JobManager.
RemoveJob
(job as Job2, this, true, false);


<animation-keyframes> generates keyframes for performant expand/collapse animations. The technique consists in using scale transforms when animating clips, and prevent the skewing of the content by counter-scaling it. See more details here.
Some examples:


Want to be featured in our new members section? Send us a photo along with you new member signup!
Tommy Valentine -California
Gavin Kooning -S. Africa
Caroline Moore - Florida
Joe Keels - Hawaii
Join our community and receive exclusive emails, special deals on Groundswell gear, tickets to surfing events, and much more! Registration is fast and free, hit us up!
User Name: User Name should be your email address.Must be a valid email address.
Password: 4 - 10 characters.4 - 10 characters4 - 10 characters
Confirm Password: You must have a password!This doesn't match your password.
First Name:
Last Name:
What region are you in? USA - East Coast USA - West Coast Hawaii Latin America Caribbean South Africa Australia
How long have you been surfing? 0 - 2 years 3 - 5 years 6 +
What Groundswell features do you use often? Shopping Surf Reports Videos Community features
Additional Comments:
I want to submit a journal!
Search lynda.com's online training library:


Curious to know more about the gut microbiome, but don't know which sources to trust?
Learn about current findings of the gut microbiome with expert-curated learning materials.
Do you wonder how your diet, exercises, medicine usage, and other habits affect your lifestyle? Ask questions that help scientists understand the human gut!
Answer fellow citizen scientists' questions. Compare your experience with others and help researchers decide what to study next.
Win American Gut kits (provided by Design Lab, UC San Diego) by sharing useful personal insights. Most novel questions might be studied by researchers at UC San Diego with your help. Help advance microbiome science!
Top Question
Have you ever been diagnosed with a food sensitivity? Does this sensitivity produce noticeable symptoms?
Top Question
Do you drink filtered water on a daily basis? If so, do you feel nauseous when you drink tap water?
Top Question
What pets currently live in your house? Do you have allergies to your pets?


I I'll a abase abate aberrant abet abeyance abjure able abnegate about above
abscond absolute abstain abstemious abstract abut abysmal accede accentuate
accolade accord accretion acerbic acetaminophen acme acquiesce acrimony across
act action actually actuate acumen adage adaptor add addition adjective adjure
admonish adroit adulation adulterate adumbrate adventitious adverse advert
advocate aesthetic affable affect afflict afraid after again against age
aggrandize aggrieve ago agreed ahead aide air alacrity alcove algorithm all
allay allege allele allow alloy almost alone along already also although always
am amalgamate ambiguity ambiguous ambivalence ambrosia ameliorate amenable
amicable among amount an anachronism anathema and angle animal animus anodyne
anomalous anomaly another answer antagonism anthropomorphic antipathy any
anything apathy aphorism apocryphal apologist apostate apotheosis apparent
appeal appear appease append apple appoint apposite apprise approach
approbation appropriate appurtenance apropos apt aquiline arabesque arbitrary
arbitrate arcane archaic archetype arduous are area argument aria armada arms
army around arrant arrest arrived arrogate art articulate artless as ascendancy
ascender ascertain ascetic ask askance asperity aspersion assail assay assent
assert assiduous assuage astringent asunder at atavism atom attenuate attitude
attribute audacious augury august auspice auspices auspicious austere automate
avarice aver aversion avocation away axiom baby back bad badinage baleful ball
banal bandwidth bandy bane bank banter base bate bauble be bear beat beatific
beatify beautiful became because become bed bedizen been before began begin
beguile behind being beleaguer belie believe bell belong below bemuse bemused
beneficent benighted benign bent bequeath beseech beside besiege best bestow
betoken betrothed better between big bilious bill birds bit black blanch bland
blandish blatant blighted blithe block blood blow blue bluster board boast boat
body boisterous bolster bolt bombastic bones book born both bottom bouillon box
boy branches brawn break bright bring broken brooch brook brother brought brown
bucolic build building built bullion bulwark burgeon burning burnish business
but buttress buxom buy by byte cabal cacophonous cadaverous cadge caffeine
cajole calculus call callous came cameo campaign can can't candid cannot canon
cant canto capacitor capital capitulate caprice capricious captain captious car
cardinal care careen carefully carrion carry case castigate cat catalyst catch
categorical cattle caucus caught cause caustic cavalier cede cells center
centrifugal centripetal cents century certain chaff chagrin chamber chance
change chaotic chart chary chastise check checkered chemosynthesis chicanery
chide chief child children choleric choose church churlish circle circumspect
circumstances circumvent cite city clad clandestine clarion class classical
clean clear cleave climbed close clothes cloud coast coax coda code codicil
cogent cognate cognitive cohere cohort coiffure cold collation color column
come commiserate commission commit common company compare compel compendium
complaisant complete comport compound comprehensive computer conceit concept
concern concomitant conditions conduct confer confluence confound congeal
conjugal conjure connoisseur connotation conscientious consecrate conservatory
consider consonant conspicuous constant constituency constitute constrained
construe contain contempt contend contentious continued contract contrite
contrive contrived control contusion convalesce convention convince convoluted
cook cool copy corn corner corpulent correct corroborate cost cotton could
couldn't count countenance countermand country course court covered cower cows
coy cozen crabbed craven create credence credible credo credulous crevice crew
cried crone crops cross crowd cryptic cryptography culpable cupidity current
cut cybernetic dais dance dapper dark database daunt day dead deal dearth death
debacle debase decadence decided decimal declivity decorum decree deduce deep
deference defray deign delete deleterious delicacy delve demonstrable
demoralize demur denigrate denouement dense depose deprave deprecate
depredation derelict deride derivative derived describe descry desert desiccate
design despair despoil desultory details determine developed device devolve
diadem diatribe dictionary dictum did didactic didn't died difference different
difficult diffidence diffident digress dilatory dilettante dimension din dingy
dint direct direction dirge disabuse disaffected disapprobation disconcert
disconsolate discordant discovered discreet discrete discretion discretionary
discriminating discursive disembark disgorge disingenuous disinterested disk
disparage disparate dispassionate dispatch disport disposition disquisition
dissemble dissimulate dissolution dissonance distance distend distinction
diversified divided division divulge do docile doctor does doesn't dog dogged
doggerel dogmatic dollars don't done door dormer dotage dote down draw drawing
dregs dress drive drop dry dulcet dupe during dutiful dwell dyspeptic each
early earnest ears earth east easy eat ebb ebullience eclectic edge edict
edifice effect effervescence effete efficacy effluvium effrontery effulgence
eggs egregious eigenvector eight either elaborate electric electron elegy
elements ellipsis eloquent else elude elysian emblazon emboss embroil emend
emetic emollient emolument empirical emulate enamor encapsulate enclave
encomium encroachment encumber end endemic endorphin endow endue enduring
energy enervate engage engender engine enigma enigmatic enjoin enjoy enough
enrapture ensconce ensue entered entertain entire entomology entreat entropy
ephemeral equable equal equation equivocate erode errant erstwhile erudite
eschew esoteric especially espouse establish esteem estrange eugenic eulogy
euphony evanescence evanescent even evening ever every everyone everything
evident exacerbate exactly exalt example exasperate except excise exciting
excoriate exculpate execrable execrate exegesis exercise exert exertion exhort
exigency exigent exonerate exorbitant expatiate expect experience experiment
expiate explain explicate exploit exploitation expostulation express expression
extant extenuate extol extort extravagant eye face facetious facile fact
faction factious factitious factories factors factory fad fall fallacious
fallow family famous fancy fanfare far fare farm farmers fast father fathom
fatuous fawn fawning fear feel feeling feet feign felicitous fell felt fervent
fervid fetid fetter few fiasco field fig fight figure filch file filial filled
finally financial find fine fingers finished fire firebrand first fish fission
fissure fit fitful five flag flail flair flat flay fledgling flippant floor
florid flotilla flourish flout flow flowers fly focus foil foist follow foment
food foolhardy foot for force ford forebear foreboding forest forestall form
formal forsake fortitude fortuitous forward foster found four fracas fraction
fractious fraught fray free fresco fresh friends frieze from front frontier
fructify fruit frustrate full fulminate fun function functionary furnish fusion
gadfly gainsay gale game garble garden garish garrulous gas gauche gaunt gave
gawk general generate genesis genetic genome gentility gentry gestate get gibe
gird girl gist give glass glib global glower go gold gone good gossamer got
gouge government granary grandiloquence grandiloquent grant grapple grass
gratis gravity great green gregarious grew gripe grisly ground group grove
grovel grow grudging gruel guess guile guileless gullible gun gusto gusty
hackneyed had haggle hair halcyon hale halt halting hand happened happy
harangue hard harrowing harry has hat have he head headlong hear heard heart
heat heavy heed hegemony held help her herculean here hermitage hew heyday high
hill him himself hireling his history hit hoary hold hole home homespun homily
homogeneous hoodwink hope horde horse hot hours house how however hubbub huge
human humble humiliate hummock hundred hunting hurtle husbandry hyperbole
hypothesis ibuprofen ice iconoclast idea idempotent ideology idiosyncrasy
idolatrous if ignominious ignominy illustrious imbibe immure immutable impart
impassive impecunious impede impel imperious impertinent imperturbable
impetuous impetus impiety implacable implement impolitic import important
importunate imposed imposing imposition imposture improvident impugn in
incandescent inches inchoate incidental incipient incisive inclement inclined
include inclusive incongruity inconsequential incorrigible increase inculcate
indemnify indicate indication indigence indite indolent industry inert inertia
infallible infest inflammatory information ingenuous ingrained ingratiate
inherent inheritance inhibit inimical inimitable iniquitous iniquity innate
innocuous inscrutable insects insensate insensible inside insinuate insipid
insist inspire instance instead institute instruments insular insurgent intend
interdict interest interminable internet interpolate intimate into intractable
intransigent intrepid intrigue inundate inured invective inveigh invidious
invocation irascible irksome iron irresolute is island isn't isomorphic issue
it it's itinerant its itself jet jibe job jocund joined jumped junket just
justify keen keep kept key killed kind kindle kinetic king knack knew knight
knoll know known kwashiorkor labor laconic lady laggard lake lament lancet land
language languid larder large largesse lassitude last latent later latitude
laud laughed law lay lead league learn least leave led left legs length less
let let's lethargic letter level levity liberal libertine library libretto lie
life lifted light like limpid line lineament list listen little live livelihood
loath located lode lofty logically long look loop loose loquacious lost lot
loud lout love low lucid lugubrious luminary luminous luxuriant machination
machine macroscopic made madrigal magic magisterial magnanimity main major
majority make makeshift malaise malcontent malevolent malice malinger malleable
man manifest manifestation mannered manumit many map maraud march mark martinet
masticate match material matrix matter maul maverick maxim may maybe me mean
meander measure meat meet megabyte melancholy melody members men mendacious
mendacity mendicant mercurial merit metal method meticulous mettle microcosm
microscopic middle mien might mile milk million minatory mincing mind mine
minute minutes misanthrope miserly miss mite mitigate mitochondrion mode modern
modest modicum module molecule molecules mollify moment monetary money months
moon moot morbid mordant more moribund morning morose mortify most mote mother
mountain mountebank mouth move movement much multifaceted multitude mundane
munificent muse music must muster my myriad name nascent nation natty natural
near necessary need neophyte nettle neutron never new next nexus nicety night
nihilist no node noisome nominal nonentity nonplus nor north northern nose
nostrum not note nothing notice notion notwithstanding noun novel novitiate now
noxious nuance nuclear null number numeral obdurate object objective obloquy
obsequious observe obstinate obtain obtrude obtuse obviate occlude ocean odious
odium of off office officious often oh oil old ominous omniscient on once one
onerous only onomatopoeia onset opaque open operator opposite oppress
opprobrium or oratorio orbital ordain order ornate orthogonal oscillate
ostensible ostentatious other our out outside outskirts over overbearing
overweening own oxygen oxymoron pacifist pacify package page paint pair
palatable palatial pall palliate pallid palpitate panegyric paper parable
paradigm paradox paragon paragraph parameter paraphernalia parity park
parochial parry parsimonious part partial partiality particular partisan party
passage passe passed past pastoral pathological patrician patronize pattern
paucity pay peccadillo pedagogue pedantic pedestrian pellucid penchant
pendulous penurious penury peon people per peremptory perennial perfidious
perfidy perfunctory perhaps period perish permeate pernicious peroration
perpetrate perpetual persist person perspicuous pert pertinacious peruse
pervade petulant phenotype pheromone philanthropic philology philosophical
philosophy phlegmatic photon phrase picked picture piece piezoelectric pilfer
pillage pillory pinion pious pique pithy placate place placebo plains plan
plane plant plants plastic platitude play plead please plenitude plethora plumb
plural plus podium poem poignancy point pole polemic polemical policy polity
polynomial pomp pontifical poor position possible postulate pounds power
practice practitioner pragmatic prattle precarious precept precipitate
precision precursor predecessor preen premise prepared presidents presumptuous
preternatural pretty prevaricate printed pristine private probably probity
problem procedural proceeding proceeds process proclivity prodigal produce
products prognosticate program project projection proletarian prolix
promiscuous propensity property propitiate propitious propriety prosaic
proscribe prospective protected proton provender provide provoke prowess proxy
prude public pucker puissant pulled pummel pundit pungent purport purse purvey
pushed pusillanimous put quaff quagmire quail qualify quantum quark querulous
questions quickly quiet quip quite quotidian race radio radioactive rail
raillery raiment rain raised rakish ramify rampart ran rancor rancorous range
ranging rankle rapt rarefied rarefy rather ratify rationalism rave ravel
reached reactionary read readjustment ready really reason rebuke rebus
recalcitrant recant received recondite record recourse recovering red redolent
redoubtable refectory reflect refraction refractory refute region rejoinder
relativity relegate remain remember remission remonstrate rend render renegade
renege rent repast repeal repeated repine report represent reprise reprobate
reprobation reproof repudiate require rescind resent resolute resonant resource
rest restrained result retainer retentive reticent retinue retiring retort
retrench retrovirus return revelry reverent reverie revulsion rhetoric rhythm
rich ride rider right rile ring ripple rise river road rock rococo roil rolled
room root rope rose roseate round rout row rubric rudiment rue rule run ruse
safe sagacious said sail salacious salient salubrious salutary same sanction
sand sat sate satiate satire saturnine savant save saw say scabbard scale
scarce scheme school science scientists scintilla score scrupulous scrutinize
sea seat second section sedulous see seeds seem seemly seen seethe sell
semblance send sense sent sentence sententious sentient sentinel separate serve
set settled seven several sextant shall shape shard sharp she sherbet ship
shoes shop short should shoulder shouted show shown side siege sight sign
signal silent similar simper simple since sinecure sing singularity sinuous sir
sister sit six size skill skin skittish sky slake slay sleep sleight slew
slowly sluice small smattering smell smiled snow so sob soft software soil
soldiers solicitous solution some someone something sometimes son song sonorous
soon soporific sordid sound south southern space spangle spat spate speak
special specious spectral speed spell spindle sporadic spot spread spring
spurious squalor square squeamish staid stake stanch stand stars start state
statement stay steel steep stentorian step stick still stilted stint stipulate
stock stoic stolid stone stood stop store story straight strange stratum stream
street stretched striate striated stricture string strong strut students study
stultify stump stupendous suavity subaltern subject subjugate sublimate sublime
subpoena subside substances substantial succinct succor such suddenly suffix
suffrage sugar suggested sully sultry sum summer sun super superannuated
supercilious suppliant supply suppose sure surface surly surprise surreptitious
suspended swerve swim sybarite sycophant syllables syllogism symbols symmetry
system table tacit taciturn tail take talisman talk tall tarry tawdry teacher
team teem tell temper temperate temperature temporize ten tenable tenacious
tendentious tenuous terms territory terse test testator than that the their
them themselves then theoretical theory there these they thick thin thing think
third this those though thought thousands thrall thread threadbare three throng
through thus tide tied time timorous tiny tirade to today together toil told
tone too took tools top torpid tortuous total touch tour tout toward town track
tract tractable trade traduce train trappings travel tread tree trenchant
triangle tribunal trip trite triumvirate troth trouble truck truculent true try
tube turbid tureen turgid turn turpitude tutelage two type typography tyro
ulterior umbrage unaffected unanimity unassuming uncle unconscionable uncouth
unction under underline understand undertake undertaking undulate
unexceptionable unfaltering ungainly unimpeachable unit unmitigated unseemly
until untoward unwonted up upbraid upon upshot urbane us use user usually usurp
utter vacate vacillate vagary vain valley value vapid various vassal vat vector
venal venerable venerate venial venture veracious verb verbose veritable very
vestige vestigial vestment vex view vilify village vindicate vindictive vintner
virtual virtuoso visage viscid viscosity viscous visit vitiate vituperate
vociferous voice volatile voluble voracious vowel waffle wait waive walk wall
wander want wanton war warble warm warrant was wash wasn't watch water waver
waves wax way waylay we we'll wear weather week weigh weight well welt welter
went were west western what wheedle wheels when where whet whether which while
whimsical white whittle who whole whorl whose why wide wife wild will willful
win wind window wings winter wire wish wistful with within without wizened
woman women won't wonder wont wood word work workers world would wouldn't
wraith wrangle wreak write written wrong wrote wry yard year yellow yeoman yes
yet yield you you're young your yourself zealot zenith zephyr


101 DALMATIANS A film review by Michael John Legeros Copyright 1996 Michael John Legeros
101 Cross-Promotions
(Walt Disney) Directed by Stephen Herek Written by John Hughes, based on the novel by Dodie Smith Cast Glenn Close, Jeff Daniels, Joely Richardson, Joan Plowright, Hugh Laurie, Mark Williams, John Shrapnel MPAA Rating "G" Running Time 103 minutes Reviewed at General Cinemas at Pleasant Valley, Raleigh, NC (27NOV96)
==
Tragic, perhaps, the fate that befalls the Disney 'toon. In recent years, our most-beloved family features have been transformed into Saturday morning cartoons (THE LION KING), sequelized in made- for-video movies (ALADDIN), and, even, staged on Broadway as fully- functioning musical productions (BEAUTY AND THE BEAST). Is anyone really surprised, then, by a live-action remake of ONE HUNDRED AND ONE DALMATIANS? Talk about future marketing strategy! Just pick any ol' classic in Walt's vaults, re-release it into theaters, then re-release it on video, and then remake it as a big-budget "event picture." Throw in a boatload of licensed products, a video re- lease for the remake, and a subsequent airing on ABC/Disney, and you've made millions. If not billions. Repeat every five years-- duh, to cash in on the current crop of toddlers-- and another four-way stock split before the end of the decade is guaranteed. Just like that.
Happily, the sound of ringing registers is but a soft echo in this exceptionally warm and fuzzy (furry?) remake. Jeff Daniels and Joely Richardson have a wonderful chemistry as the London dog owners who fall in love after their Dalmatians do. (Though I had to think twice if I was watching the guy who played the President in INDEPENDENCE DAY. No, that was Bill Pullman.) They're also a world more interest- ing than Glenn Close, whose narrow performance as Cruella De Vil is the year's most overrated. (Blame the script.  Most impressive are the technical credits, from art direction to animal handling to location photography. Some of the best production work of the year is on display.
Too bad that the script, by John Hughes, doesn't let the dogs talk. Several later sequences of inter-breed interaction are particularly tiresome. (Woof. Cut to dog barking. Woof. Cut to other dog listening. Woof. Cut to first dog running in direction of second dog. Repeat several times.) Another major problem of the script is Hughes' overabundance of violent physical humor. Okay, I laughed at the bumbling bad guys (Hugh Laurie and Mark Williams, both nicely underplaying) getting their 'nads fried on an electric fence, but this movie really deserves something more than the unintended alternate title of HOME ALONE 3: SEEING SPOTS. I don't even know if I can recommend this to young kids, as they'd probably fall asleep somewhere in the middle.
Grade: B-
-- Mike Legeros - Raleigh, NC, USA, Earth<EMAIL_ADDRESS>(h) -<EMAIL_ADDRESS>(w) I'm also on the Web! http://www.pagesz.net/~legeros/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


We do have one problem, though. The thread that we hijacked had a purpose before we had hijacked it. If we don’t restore its execution, there is no telling what kind of effect we could have on the target process.
How do we restore execution? I’d like to remind you that we are now in the context of an APC. When the APC function completes, somehow execution is restored safely. Let’s look at the dispatching of APCs from the target process’s point of view.
It looks like the function in charge of dispatching APCs (WaitForSingleObjectEx in this example) is ntdll!KiUserApcDispatcher.
We can see 3 “calls” in this block of code. The first call is to CFG, the next call is to ECX (which is the address of the APC function), and finally a call to the undocumented ZwContinue.
ZwContinue expects to receive a pointer to a CONTEXT structure and resumes the execution. Actually the kernel will check if there are any more APCs in the thread’s APC queue, and dispatch them before finally resuming the thread’s original execution, but we can ignore that.
The CONTEXT structure being passed to ZwContinue is stored in EDI before calling the APC function (stored in ECX). We can save EDI’s value at the beginning of our shellcode, and call ZwContinue with EDI’s original value at the end of the shellcode, thereby restoring execution safely.
See AtomBombingShellcode in AtomBombing’s GitHub repository.
We have to make sure that the value of EDI will not be overridden during the call to NtSetContextThread, since it modifies the values of the registers. This can easily be accomplished by setting ContextFlags (member of the CONTEXT structure passed to NtSetContextThread) to CONTEXT_CONTROL which means that only EBP, EIP, SEGCS, EFLAGS, ESP, and SEGSS will be affected. As long as (CONTEXT.ContextFlags|CONTEXT_INTEGER == 0) we should be ok.
And there you have it, we have injected code into chrome.exe. Our injected code spawned the classic calc.exe proving that it works.
Let’s try to inject code into vlc.exe:
The complete implementation can be found on GitHub. It has been tested against Windows 10 x64 Build 1511 (WOW) and Windows 10 x86 Build 10240. Compile for “release”.
Let’s do the same with mspaint.exe:


Facial Sunscreen
MoreCard title
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Go somewhereCard title
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
Last updated 3 mins ago
Go somewhere


Name
Last Name
Email
Phone
Gender
Date of Birth
Age
Address
City
State
Pin code
Country
Select University
Highest Qualification
Year Of completion
Specify Your Current Employement Status
Upload your resume
© 2020 Employee Details Form. All rights reserved | Design & Developed by HRMTeam


FIFA 20
£5000
Add to Cart
GTA 5
£3000
Add to Cart
WATCHDOG
£2000
Add to Cart
Product
Title
Price
Action
Total ₹
0