# Краткое руководство по машинному обучению¶

Краткое и доступное объяснение концепций машинного обучения с диаграммами, примерами кода и ссылками на внешние ресурсы для самостоятельного углубленного изучения.

Предупреждение

Данное руководство находится в стадии ранней разреботки. Оно является вольным переводом англоязычного руководства Machine Learning Cheatsheet. Если вы нашли ошибку, пожалуйста поднимите вопрос или сделайте свой вклад для улучшения руководства!

## Линейная регрессия¶

### Введение¶

Линейная регрессия это алгоритм машинного обучения с учителем. Иными словами - алгоритму для обучения необходимо указать как входные данные так и заранее подготовленные выходные данные. Всё месте это называется обучающей выборкой. Линейная регрессия может предсказать только одно значение из бесконечно большого диапазона значений, например температуру, скорость движения спутника, и так далее.

Линейная регрессия может быть двух видов:

Простая регрессия

Простая линейная регрессия в своей основе содержит простейшую линейную формулу:

$y = mx + b$

Где $$m$$ и $$b$$ это значения, которые необходимо подобрать алгоритму для достижения наилучшей точности в своих предсказаниях. Значение $$x$$ представляет собой входные данные и $$y$$ представляет собой выходные данные.

Множественная регрессия

Более сложная форма линейной регрессии с несколькими переменными. Значения $$w$$ являются коэффициентами (ещё их называют «весами» - англ. weight), а $$x_1$$, $$x_2$$, $$x_3$$, … входными значениями. В данном случае алгоритм подбирает значения $$w$$.

$f(x,y,z) = w_1 x_1 + w_2 x_2 + w_3 x_3$

### Простая регрессия¶

Давайте представим что у нас есть следующая таблица с колонками:

 Компания Затраты на рекламу Продажи Amazon 37.8 22.1 Google 39.3 10.4 Facebook 45.9 18.3 Apple 41.3 18.5

Далее мы обучим линейную модель для предсказания количества продаж в зависимости от потраченных на рекламу денег.

#### Предсказывание¶

Наша предсказывающая модель будет выводит приближенное значение продаж в зависимости от затрат на рекламу по простой формуле линейного уравнения:

$Продажи = Вес_1 \cdot Реклама + Смещение$

или в англоязычных терминах:

$Sales = Weight \cdot Advertisment + Bias$
Weight
коэффициент независимой переменной Advertisment. В машинном обучении такие коэффициенты называют весами (weights).
независимая переменная. В машинном обучении такие переменные называют признаками (features).
Bias
Параметр смещения относительн оси y. В машинном обучении этот параметр также называют bias.

Our algorithm will try to learn the correct values for Weight and Bias. By the end of our training, our equation will approximate the line of best fit. Code

def predict_sales(radio, weight, bias):


#### Cost function¶

The prediction function is nice, but for our purposes we don’t really need it. What we need is a cost function so we can start optimizing our weights.

Let’s use MSE (L2) as our cost function. MSE measures the average squared difference between an observation’s actual and predicted values. The output is a single number representing the cost, or score, associated with our current set of weights. Our goal is to minimize MSE to improve the accuracy of our model.

Math

Given our simple linear equation $$y = mx + b$$, we can calculate MSE as:

$MSE = \frac{1}{N} \sum_{i=1}^{n} (y_i - (m x_i + b))^2$

Примечание

• $$N$$ is the total number of observations (data points)
• $$\frac{1}{N} \sum_{i=1}^{n}$$ is the mean
• $$y_i$$ is the actual value of an observation and $$m x_i + b$$ is our prediction

Code

def cost_function(radio, sales, weight, bias):
total_error = 0.0
for i in range(companies):
total_error += (sales[i] - (weight*radio[i] + bias))**2


To minimize MSE we use Gradient Descent to calculate the gradient of our cost function. [TODO: Slightly longer explanation].

Math

There are two parameters (coefficients) in our cost function we can control: weight $$m$$ and bias $$b$$. Since we need to consider the impact each one has on the final prediction, we use partial derivatives. To find the partial derivatives, we use the Chain rule. We need the chain rule because $$(y - (mx + b))^2$$ is really 2 nested functions: the inner function $$y - mx + b$$ and the outer function $$x^2$$.

Returning to our cost function:

$f(m,b) = \frac{1}{N} \sum_{i=1}^{n} (y_i - (mx_i + b))^2$

We can calculate the gradient of this cost function as:

$\begin{split}f'(m,b) = \begin{bmatrix} \frac{df}{dm}\\ \frac{df}{db}\\ \end{bmatrix} = \begin{bmatrix} \frac{1}{N} \sum -2x_i(y_i - (mx_i + b)) \\ \frac{1}{N} \sum -2(y_i - (mx_i + b)) \\ \end{bmatrix}\end{split}$

Code

To solve for the gradient, we iterate through our data points using our new weight and bias values and take the average of the partial derivatives. The resulting gradient tells us the slope of our cost function at our current position (i.e. weight and bias) and the direction we should update to reduce our cost function (we move in the direction opposite the gradient). The size of our update is controlled by the learning rate.

def update_weights(radio, sales, weight, bias, learning_rate):
weight_deriv = 0
bias_deriv = 0

for i in range(companies):
# Calculate partial derivatives
# -2x(y - (mx + b))

# -2(y - (mx + b))
bias_deriv += -2*(sales[i] - (weight*radio[i] + bias))

# We subtract because the derivatives point in direction of steepest ascent
weight -= (weight_deriv / companies) * learning_rate
bias -= (bias_deriv / companies) * learning_rate

return weight, bias


#### Training¶

Training a model is the process of iteratively improving your prediction equation by looping through the dataset multiple times, each time updating the weight and bias values in the direction indicated by the slope of the cost function (gradient). Training is complete when we reach an acceptable error threshold, or when subsequent training iterations fail to reduce our cost.

Before training we need to initializing our weights (set default values), set our hyperparameters (learning rate and number of iterations), and prepare to log our progress over each iteration.

Code

def train(radio, sales, weight, bias, learning_rate, iters):
cost_history = []

for i in range(iters):
weight,bias = update_weights(radio, sales, weight, bias, learning_rate)

#Calculate cost for auditing purposes
cost = cost_function(features, targets, weights)
cost_history.append(cost)

# Log Progress
if i % 10 == 0:
print "iter: "+str(i) + " cost: "+str(cost)

return weight, bias, cost_history


#### Model evaluation¶

If our model is working, we should see our cost decrease after every iteration.

Logging

iter=1     weight=.03    bias=.0014    cost=197.25
iter=10    weight=.28    bias=.0116    cost=74.65
iter=20    weight=.39    bias=.0177    cost=49.48
iter=30    weight=.44    bias=.0219    cost=44.31
iter=30    weight=.46    bias=.0249    cost=43.28


Visualizing    Cost history #### Summary¶

By learning the best values for weight (.46) and bias (.25), we now have an equation that predicts future sales based on radio advertising investment.

$Sales = .46 Radio + .025$

How would our model perform in the real world? I’ll let you think about it :)

### Multivariable regression¶

Let’s say we are given data on TV, radio, and newspaper advertising spend for a list of companies, and our goal is to predict sales in terms of units sold.

 Company TV Radio News Units Amazon 230.1 37.8 69.1 22.1 Google 44.5 39.3 23.1 10.4 Facebook 17.2 45.9 34.7 18.3 Apple 151.5 41.3 13.2 18.5

#### Growing complexity¶

As the number of features grows, the complexity of our model increases and it becomes increasingly difficult to visualize, or even comprehend, our data. One solution is to break the data apart and compare 1-2 features at a time. In this example we explore how Radio and TV investment impacts Sales.

#### Normalization¶

As the number of features grows, calculating gradient takes longer to compute. We can speed this up by «normalizing» our input data to ensure all values are within the same range. This is especially important for datasets with high standard deviations or differences in the ranges of the attributes. Our goal now will be to normalize our features so they are all in the range -1 to 1.

Code

For each feature column {
#1 Subtract the mean of the column (mean normalization)
#2 Divide by the range of the column (feature scaling)
}


Our input is a 200 x 3 matrix containing TV, Radio, and Newspaper data. Our output is a normalized matrix of the same shape with all values between -1 and 1.

def normalize(features):
**
features     -   (200, 3)
features.T   -   (3, 200)

We transpose the input matrix, swapping
cols and rows to make vector math easier
**

for feature in features.T:
fmean = np.mean(feature)
frange = np.amax(feature) - np.amin(feature)

#Vector Subtraction
feature -= fmean

#Vector Division
feature /= frange

return features


Примечание

Matrix math. Before we continue, it’s important to understand basic Linear Algebra concepts as well as numpy functions like numpy.dot().

#### Making predictions¶

Our predict function outputs an estimate of sales given our current weights (coefficients) and a company’s TV, radio, and newspaper spend. Our model will try to identify weight values that most reduce our cost function.

$Sales = W_1 TV + W_2 Radio + W_3 Newspaper$
def predict(features, weights):
**
features - (200, 3)
weights - (3, 1)
predictions - (200,1)
**
return np.dot(features,weights)


#### Initialize weights¶

W1 = 0.0
W2 = 0.0
W3 = 0.0
weights = np.array([
[W1],
[W2],
[W3]
])


#### Cost function¶

Now we need a cost function to audit how our model is performing. The math is the same, except we swap the $$mx + b$$ expression for $$W_1 x_1 + W_2 x_2 + W_3 x_3$$. We also divide the expression by 2 to make derivative calculations simpler.

$MSE = \frac{1}{2N} \sum_{i=1}^{n} (y_i - (W_1 x_1 + W_2 x_2 + W_3 x_3))^2$
def cost_function(features, targets, weights):
**
Features:(200,3)
Targets: (200,1)
Weights:(3,1)
Returns 1D matrix of predictions
**
N = len(targets)

predictions = predict(features, weights)

# Matrix math lets use do this without looping
sq_error = (predictions - targets)**2

# Return average squared error among predictions
return 1.0/(2*N) * sq_error.sum()


Again using the Chain rule we can compute the gradient–a vector of partial derivatives describing the slope of the cost function for each weight.

\begin{split}\begin{align} f'(W_1) = -x_1(y - (W_1 x_1 + W_2 x_2 + W_3 x_3)) \\ f'(W_2) = -x_2(y - (W_1 x_1 + W_2 x_2 + W_3 x_3)) \\ f'(W_3) = -x_3(y - (W_1 x_1 + W_2 x_2 + W_3 x_3)) \end{align}\end{split}
def update_weights(features, targets, weights, lr):
'''
Features:(200, 3)
Targets: (200, 1)
Weights:(3, 1)
'''
predictions = predict(features, weights)

#Extract our features
x1 = features[:,0]
x2 = features[:,1]
x3 = features[:,2]

# Use matrix cross product (*) to simultaneously
# calculate the derivative for each weight
d_w1 = -x1*(targets - predictions)
d_w2 = -x2*(targets - predictions)
d_w3 = -x3*(targets - predictions)

# Multiply the mean derivative by the learning rate
# and subtract from our weights (remember gradient points in direction of steepest ASCENT)
weights -= (lr * np.mean(d_w1))
weights -= (lr * np.mean(d_w2))
weights -= (lr * np.mean(d_w3))

return weights


And that’s it! Multivariate linear regression.

#### Simplifying with matrices¶

The gradient descent code above has a lot of duplication. Can we improve it somehow? One way to refactor would be to loop through our features and weights–allowing our function handle any number of features. However there is another even better technique: vectorized gradient descent.

Math

We use the same formula as above, but instead of operating on a single feature at a time, we use matrix multiplication to operative on all features and weights simultaneously. We replace the $$x_i$$ terms with a single feature matrix $$X$$.

$gradient = -X(targets - predictions)$

Code

X = [
[x1, x2, x3]
[x1, x2, x3]
[x1, x2, x3]
]

targets = [
,
,

]

def update_weights_vectorized(X, targets, weights, lr):
**
gradient = X.T * (predictions - targets) / N
X: (200, 3)
Targets: (200, 1)
Weights: (3, 1)
**
companies = len(X)

#1 - Get Predictions
predictions = predict(X, weights)

#2 - Calculate error/loss
error = targets - predictions

#3 Transpose features from (200, 3) to (3, 200)
# So we can multiply w the (200,1)  error matrix.
# Returns a (3,1) matrix holding 3 partial derivatives --
# one for each feature -- representing the aggregate
# slope of the cost function across all observations

#4 Take the average error derivative for each feature

#5 - Multiply the gradient by our learning rate

#6 - Subtract from our weights to minimize cost

return weights


#### Bias term¶

Our train function is the same as for simple linear regression, however we’re going to make one final tweak before running: add a bias term to our feature matrix.

In our example, it’s very unlikely that sales would be zero if companies stopped advertising. Possible reasons for this might include past advertising, existing customer relationships, retail locations, and salespeople. A bias term will help us capture this base case.

Code

Below we add a constant 1 to our features matrix. By setting this value to 1, it turns our bias term into a constant.

bias = np.ones(shape=(len(features),1))
features = np.append(bias, features, axis=1)


#### Model evaluation¶

After training our model through 1000 iterations with a learning rate of .0005, we finally arrive at a set of weights we can use to make predictions:

$Sales = 4.7TV + 3.5Radio + .81Newspaper + 13.9$

Our MSE cost dropped from 110.86 to 6.25. References

Gradient descent is an optimization algorithm used to minimize some function by iteratively moving in the direction of steepest descent as defined by the negative of the gradient. In machine learning, we use gradient descent to update the parameters of our model. Parameters refer to coefficients in Линейная регрессия and weights in neural networks.

### Introduction¶

Consider the 3-dimensional graph below in the context of a cost function. Our goal is to move from the mountain in the top right corner (high cost) to the dark blue sea in the bottom left (low cost). The arrows represent the direction of steepest descent (negative gradient) from any given point–the direction that decreases the cost function as quickly as possible. Source Starting at the top of the mountain, we take our first step downhill in the direction specified by the negative gradient. Next we recalculate the negative gradient (passing in the coordinates of our new point) and take another step in the direction it specifies. We continue this process iteratively until we get to the bottom of our graph, or to a point where we can no longer move downhill–a local minimum. image source. ### Learning rate¶

The size of these steps is called the learning rate. With a high learning rate we can cover more ground each step, but we risk overshooting the lowest point since the slope of the hill is constantly changing. With a very low learning rate, we can confidently move in the direction of the negative gradient since we are recalculating it so frequently. A low learning rate is more precise, but calculating the gradient is time-consuming, so it will take us a very long time to get to the bottom.

### Cost function¶

A Loss Functions tells us «how good» our model is at making predictions for a given set of parameters. The cost function has its own curve and its own gradients. The slope of this curve tells us how to update our parameters to make the model more accurate.

### Step-by-step¶

Now let’s run gradient descent using our new cost function. There are two parameters in our cost function we can control: $$m$$ (weight) and $$b$$ (bias). Since we need to consider the impact each one has on the final prediction, we need to use partial derivatives. We calculate the partial derivatives of the cost function with respect to each parameter and store the results in a gradient.

Math

Given the cost function:

$f(m,b) = \frac{1}{N} \sum_{i=1}^{n} (y_i - (mx_i + b))^2$

The gradient can be calculated as:

$\begin{split}f'(m,b) = \begin{bmatrix} \frac{df}{dm}\\ \frac{df}{db}\\ \end{bmatrix} = \begin{bmatrix} \frac{1}{N} \sum -2x_i(y_i - (mx_i + b)) \\ \frac{1}{N} \sum -2(y_i - (mx_i + b)) \\ \end{bmatrix}\end{split}$

To solve for the gradient, we iterate through our data points using our new $$m$$ and $$n$$ values and compute the partial derivatives. This new gradient tells us the slope of our cost function at our current position (current parameter values) and the direction we should move to update our parameters. The size of our update is controlled by the learning rate.

Code

def update_weights(m, b, X, Y, learning_rate):
m_deriv = 0
b_deriv = 0
N = len(X)
for i in range(N):
# Calculate partial derivatives
# -2x(y - (mx + b))
m_deriv += -2*X[i] * (Y[i] - (m*X[i] + b))

# -2(y - (mx + b))
b_deriv += -2*(Y[i] - (m*X[i] + b))

# We subtract because the derivatives point in direction of steepest ascent
m -= (m_deriv / float(N)) * learning_rate
b -= (b_deriv / float(N)) * learning_rate

return m, b


References

## Logistic Regression¶

### Introduction¶

Logistic regression is a classification algorithm used to assign observations to a discrete set of classes. Unlike linear regression which outputs continuous number values, logistic regression transforms its output using the logistic sigmoid function to return a probability value which can then be mapped to two or more discrete classes.

#### Comparison to linear regression¶

Given data on time spent studying and exam scores. Линейная регрессия and logistic regression can predict different things:

• Linear Regression could help us predict the student’s test score on a scale of 0 - 100. Linear regression predictions are continuous (numbers in a range).
• Logistic Regression could help use predict whether the student passed or failed. Logistic regression predictions are discrete (only specific values or categories are allowed). We can also view probability scores underlying the model’s classifications.

#### Types of logistic regression¶

• Binary (Pass/Fail)
• Multi (Cats, Dogs, Sheep)
• Ordinal (Low, Medium, High)

### Binary logistic regression¶

Say we’re given data on student exam results and our goal is to predict whether a student will pass or fail based on number of hours slept and hours spent studying. We have two features (hours slept, hours studied) and two classes: passed (1) and failed (0).

 Studied Slept Passed 4.85 9.63 1 8.62 3.23 0 5.43 8.23 1 9.21 6.34 0

Graphically we could represent our data with a scatter plot. #### Sigmoid activation¶

In order to map predicted values to probabilities, we use the sigmoid function. The function maps any real value into another value between 0 and 1. In machine learning, we use sigmoid to map predictions to probabilities.

Math

$S(z) = \frac{1} {1 + e^{-z}}$

Примечание

• $$s(z)$$ = output between 0 and 1 (probability estimate)
• $$z$$ = input to the function (your algorithm’s prediction e.g. mx + b)
• $$e$$ = base of natural log

Graph Code

#### Decision boundary¶

Our current prediction function returns a probability score between 0 and 1. In order to map this to a discrete class (true/false, cat/dog), we select a threshold value or tipping point above which we will classify values into class 1 and below which we classify values into class 2.

$\begin{split}p \geq 0.5, class=1 \\ p < 0.5, class=0\end{split}$

For example, if our threshold was .5 and our prediction function returned .7, we would classify this observation as positive. If our prediction was .2 we would classify the observation as negative. For logistic regression with multiple classes we could select the class with the highest predicted probability. #### Making predictions¶

Using our knowledge of sigmoid functions and decision boundaries, we can now write a prediction function. A prediction function in logistic regression returns the probability of our observation being positive, True, or «Yes». We call this class 1 and its notation is $$P(class=1)$$. As the probability gets closer to 1, our model is more confident that the observation is in class 1.

Math

Let’s use the same multiple linear regression equation from our linear regression tutorial.

$z = W_0 + W_1 Studied + W_2 Slept$

This time however we will transform the output using the sigmoid function to return a probability value between 0 and 1.

$P(class=1) = \frac{1} {1 + e^{-z}}$

If the model returns .4 it believes there is only a 40% chance of passing. If our decision boundary was .5, we would categorize this observation as «Fail.»«

Code

We wrap the sigmoid function over the same prediction function we used in multiple linear regression

def predict(features, weights):
'''
Returns 1D array of probabilities
that the class label == 1
'''
z = np.dot(features, weights)
return sigmoid(z)


#### Cost function¶

Unfortunately we can’t (or at least shouldn’t) use the same cost function MSE (L2) as we did for linear regression. Why? There is a great math explanation in chapter 3 of Michael Neilson’s deep learning book , but for now I’ll simply say it’s because our prediction function is non-linear (due to sigmoid transform). Squaring this prediction as we do in MSE results in a non-convex function with many local minimums. If our cost function has many local minimums, gradient descent may not find the optimal global minimum.

Math

Instead of Mean Squared Error, we use a cost function called Cross-Entropy, also known as Log Loss. Cross-entropy loss can be divided into two separate cost functions: one for $$y=1$$ and one for $$y=0$$. The benefits of taking the logarithm reveal themselves when you look at the cost function graphs for y=1 and y=0. These smooth monotonic functions  (always increasing or always decreasing) make it easy to calculate the gradient and minimize cost. Image from Andrew Ng’s slides on logistic regression . The key thing to note is the cost function penalizes confident and wrong predictions more than it rewards confident and right predictions! The corollary is increasing prediction accuracy (closer to 0 or 1) has diminishing returns on reducing cost due to the logistic nature of our cost function.

Above functions compressed into one Multiplying by $$y$$ and $$(1-y)$$ in the above equation is a sneaky trick that let’s us use the same equation to solve for both y=1 and y=0 cases. If y=0, the first side cancels out. If y=1, the second side cancels out. In both cases we only perform the operation we need to perform.

Vectorized cost function Code

def cost_function(features, labels, weights):
'''
Using Mean Absolute Error

Features:(100,3)
Labels: (100,1)
Weights:(3,1)
Returns 1D matrix of predictions
Cost = ( log(predictions) + (1-labels)*log(1-predictions) ) / len(labels)
'''
observations = len(labels)

predictions = predict(features, weights)

#Take the error when label=1
class1_cost = -labels*np.log(predictions)

#Take the error when label=0
class2_cost = (1-labels)*np.log(1-predictions)

#Take the sum of both costs
cost = class1_cost - class2_cost

#Take the average cost
cost = cost.sum()/observations

return cost


To minimize our cost, we use Gradient Descent just like before in Линейная регрессия. There are other more sophisticated optimization algorithms out there such as conjugate gradient like BFGS, but you don’t have to worry about these. Machine learning libraries like Scikit-learn hide their implementations so you can focus on more interesting things!

Math

One of the neat properties of the sigmoid function is its derivative is easy to calculate. If you’re curious, there is a good walk-through derivation on stack overflow . Michael Neilson also covers the topic in chapter 3 of his book.

\begin{align} s'(z) & = s(z)(1 - s(z)) \end{align}

Which leads to an equally beautiful and convenient cost function derivative:

$C' = x(s(z) - y)$

Примечание

• $$C'$$ is the derivative of cost with respect to weights
• $$y$$ is the actual class label (0 or 1)
• $$s(z)$$ is your model’s prediction
• $$x$$ is your feature or feature vector.

Notice how this gradient is the same as the MSE (L2) gradient, the only difference is the hypothesis function.

Pseudocode

Repeat {

2. Multiply by learning rate
3. Subtract from weights

}


Code

def update_weights(features, labels, weights, lr):
'''

Features:(200, 3)
Labels: (200, 1)
Weights:(3, 1)
'''
N = len(features)

#1 - Get Predictions
predictions = predict(features, weights)

#2 Transpose features from (200, 3) to (3, 200)
# So we can multiply w the (200,1)  cost matrix.
# Returns a (3,1) matrix holding 3 partial derivatives --
# one for each feature -- representing the aggregate
# slope of the cost function across all observations
gradient = np.dot(features.T,  predictions - labels)

#3 Take the average cost derivative for each feature

#4 - Multiply the gradient by our learning rate

#5 - Subtract from our weights to minimize cost

return weights


#### Mapping probabilities to classes¶

The final step is assign class labels (0 or 1) to our predicted probabilities.

Decision boundary

def decision_boundary(prob):
return 1 if prob >= .5 else 0


Convert probabilities to classes

def classify(preds):
'''
input  - N element array of predictions between 0 and 1
output - N element array of 0s (False) and 1s (True)
'''
decision_boundary = np.vectorize(decision_boundary)
return decision_boundary(predictions).flatten()


Example output

Probabilities = [ 0.967, 0.448, 0.015, 0.780, 0.978, 0.004]
Classifications = [1, 0, 0, 1, 1, 0]


#### Training¶

Our training code is the same as we used for linear regression.

def train(features, labels, weights, lr, iters):
cost_history = []

for i in range(iters):
weights = update_weights(features, labels, weights, lr)

#Calculate error for auditing purposes
cost = cost_function(features, labels, weights)
cost_history.append(cost)

# Log Progress
if i % 1000 == 0:
print "iter: "+str(i) + " cost: "+str(cost)

return weights, cost_history


#### Model evaluation¶

If our model is working, we should see our cost decrease after every iteration.

iter: 0 cost: 0.635
iter: 1000 cost: 0.302
iter: 2000 cost: 0.264


Final cost: 0.2487. Final weights: [-8.197, .921, .738]

Cost history Accuracy

Accuracy measures how correct our predictions were. In this case we simple compare predicted labels to true labels and divide by the total.

def accuracy(predicted_labels, actual_labels):
diff = predicted_labels - actual_labels
return 1.0 - (float(np.count_nonzero(diff)) / len(diff))


Decision boundary

Another helpful technique is to plot the decision boundary on top of our predictions to see how our labels compare to the actual labels. This involves plotting our predicted probabilities and coloring them with their true labels. Code to plot the decision boundary

def plot_decision_boundary(trues, falses):
fig = plt.figure()

no_of_preds = len(trues) + len(falses)

ax.scatter([i for i in range(len(trues))], trues, s=25, c='b', marker="o", label='Trues')
ax.scatter([i for i in range(len(falses))], falses, s=25, c='r', marker="s", label='Falses')

plt.legend(loc='upper right');
ax.set_title("Decision Boundary")
ax.set_xlabel('N/2')
ax.set_ylabel('Predicted Probability')
plt.axhline(.5, color='black')
plt.show()


### Multiclass logistic regression¶

Instead of $$y = {0,1}$$ we will expand our definition so that $$y = {0,1...n}$$. Basically we re-run binary classification multiple times, once for each class.

#### Procedure¶

1. Divide the problem into n+1 binary classification problems (+1 because the index starts at 0?).
2. For each class…
3. Predict the probability the observations are in that single class.
4. prediction = [itex]max(probability of the classes)

For each sub-problem, we select one class (YES) and lump all the others into a second class (NO). Then we take the class with the highest predicted value.

#### Scipy example¶

Let’s compare our performance to the LogisticRegression model provided by scikit-learn .

import sklearn
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split

# Normalize grades to values between 0 and 1 for more efficient computation
normalized_range = sklearn.preprocessing.MinMaxScaler(feature_range=(-1,1))

# Extract Features + Labels
labels.shape =  (100,) #scikit expects this
features = normalized_range.fit_transform(features)

# Create Test/Train
features_train,features_test,labels_train,labels_test = train_test_split(features,labels,test_size=0.4)

# Scikit Logistic Regression
scikit_log_reg = LogisticRegression()
scikit_log_reg.fit(features_train,labels_train)

#Score is Mean Accuracy
scikit_score = clf.score(features_test,labels_test)
print 'Scikit score: ', scikit_score

#Our Mean Accuracy
observations, features, labels, weights = run()
probabilities = predict(features, weights).flatten()
classifications = classifier(probabilities)
our_acc = accuracy(classifications,labels.flatten())
print 'Our score: ',our_acc


Scikit score: 0.88. Our score: 0.89

References

## Glossary¶

Definitions of common machine learning terms.

Accuracy
Percentage of correct predictions made by the model.
Algorithm
A method, function, or series of instructions used to generate a machine learning model. Examples include linear regression, decision trees, support vector machines, and neural networks.
Attribute
A quality describing an observation (e.g. color, size, weight). In Excel terms, these are column headers.
Bias metric

What is the average difference between your predictions and the correct value for that observation?

• Low bias could mean every prediction is correct. It could also mean half of your predictions are above their actual values and half are below, in equal proportion, resulting in low average difference.
• High bias (with low variance) suggests your model may be underfitting and you’re using the wrong architecture for the job.
Bias term
Allow models to represent patterns that do not pass through the origin. For example, if all my features were 0, would my output also be zero? Is it possible there is some base value upon which my features have an effect? Bias terms typically accompany weights and are attached to neurons or filters.
Categorical Variables
Variables with a discrete set of possible values. Can be ordinal (order matters) or nominal (order doesn’t matter).
Classification
Predicting a categorical output (e.g. yes or no?, blue, green or red?).
Classification Threshold
The lowest probability value at which we’re comfortable asserting a positive classification. For example, if the predicted probability of being diabetic is > 50%, return True, otherwise return False.
Clustering
Unsupervised grouping of data into buckets.
Confusion Matrix

Table that describes the performance of a classification model by grouping predictions into 4 categories.

• True Positives: we correctly predicted they do have diabetes
• True Negatives: we correctly predicted they don’t have diabetes
• False Positives: we incorrectly predicted they do have diabetes (Type I error)
• False Negatives: we incorrectly predicted they don’t have diabetes (Type II error)
Continuous Variables
Variables with a range of possible values defined by a number scale (e.g. sales, lifespan).
Deduction
A top-down approach to answering questions or solving problems. A logic technique that starts with a theory and tests that theory with observations to derive a conclusion. E.g. We suspect X, but we need to test our hypothesis before coming to any conclusions.
Deep Learning
Contribute a definition!
Dimension
Contribute a definition!
Epoch
An epoch describes the number of times the algorithm sees the entire data set.
Extrapolation
Making predictions outside the range of a dataset. E.g. My dog barks, so all dogs must bark. In machine learning we often run into trouble when we extrapolate outside the range of our training data.
Feature
With respect to a dataset, a feature represents an attribute and value combination. Color is an attribute. «Color is blue» is a feature. In Excel terms, features are similar to cells. The term feature has other definitions in different contexts.
Feature Selection
Feature selection is the process of selecting relevant features from a data-set for creating a Machine Learning model.
Feature Vector
A list of features describing an observation with multiple attributes. In Excel we call this a row.
Hyperparameters
Hyperparameters are higher-level properties of a model such as how fast it can learn (learning rate) or complexity of a model. The depth of trees in a Decision Tree or number of hidden layers in a Neural Networks are examples of hyper parameters.
Induction
A bottoms-up approach to answering questions or solving problems. A logic technique that goes from observations to theory. E.g. We keep observing X, so we <b><i>infer</i></b> that Y must be True.
Instance
A data point, row, or sample in a dataset. Another term for observation.
Learning Rate
The size of the update steps to take during optimization loops like Gradient Descent. With a high learning rate we can cover more ground each step, but we risk overshooting the lowest point since the slope of the hill is constantly changing. With a very low learning rate, we can confidently move in the direction of the negative gradient since we are recalculating it so frequently. A low learning rate is more precise, but calculating the gradient is time-consuming, so it will take us a very long time to get to the bottom.
Loss
Contribute a definition!
Machine Learning
Contribute a definition!
Model
A data structure that stores a representation of a dataset (weights and biases). Models are created/learned when you train an algorithm on a dataset.
Neural Networks
Contribute a definition!
Normalization
Contribute a definition!
Null Accuracy
Baseline accuracy that can be acheived by always predicting the most frequent class («B has the highest frequency, so lets guess B every time»).
Observation
A data point, row, or sample in a dataset. Another term for instance.
Overfitting
Overfitting occurs when your model learns the training data too well and incorporates details and noise specific to your dataset. You can tell a model is overfitting when it performs great on your training/validation set, but poorly on your test set (or new real-world data).
Parameters
Be the first to contribute!
Precision

In the context of binary classification (Yes/No), precision measures the model’s performance at classifying positive observations (i.e. «Yes»). In other words, when a positive value is predicted, how often is the prediction correct? We could game this metric by only returning positive for the single observation we are most confident in.

$P = \frac{True Positives}{True Positives + False Positives}$
Recall

Also called sensitivity. In the context of binary classification (Yes/No), recall measures how «sensitive» the classifier is at detecting positive instances. In other words, for all the true observations in our sample, how many did we «catch.» We could game this metric by always classifying observations as positive.

$R = \frac{True Positives}{True Positives + False Negatives}$
Recall vs Precision

Say we are analyzing Brain scans and trying to predict whether a person has a tumor (True) or not (False). We feed it into our model and our model starts guessing.

• Precision is the % of True guesses that were actually correct! If we guess 1 image is True out of 100 images and that image is actually True, then our precision is 100%! Our results aren’t helpful however because we missed 10 brain tumors! We were super precise when we tried, but we didn’t try hard enough.
• Recall, or Sensitivity, provides another lens which with to view how good our model is. Again let’s say there are 100 images, 10 with brain tumors, and we correctly guessed 1 had a brain tumor. Precision is 100%, but recall is 10%. Perfect recall requires that we catch all 10 tumors!
Regression
Predicting a continuous output (e.g. price, sales).
Regularization
Contribute a definition!
Reinforcement Learning
Training a model to maximize a reward via iterative trial and error.
Segmentation
Contribute a definition!
Specificity

In the context of binary classification (Yes/No), specificity measures the model’s performance at classifying negative observations (i.e. «No»). In other words, when the correct label is negative, how often is the prediction correct? We could game this metric if we predict everything as negative.

$S = \frac{True Negatives}{True Negatives + False Positives}$
Supervised Learning
Training a model using a labeled dataset.
Test Set
A set of observations used at the end of model training and validation to assess the predictive power of your model. How generalizable is your model to unseen data?
Training Set
A set of observations used to generate machine learning models.
Transfer Learning
Contribute a definition!
Type 1 Error
False Positives. Consider a company optimizing hiring practices to reduce false positives in job offers. A type 1 error occurs when candidate seems good and they hire him, but he is actually bad.
Type 2 Error
False Negatives. The candidate was great but the company passed on him.
Underfitting
Underfitting occurs when your model over-generalizes and fails to incorporate relevant variations in your data that would give your model more predictive power. You can tell a model is underfitting when it performs poorly on both training and test sets.
Universal Approximation Theorem
A neural network with one hidden layer can approximate any continuous function but only for inputs in a specific range. If you train a network on inputs between -2 and 2, then it will work well for inputs in the same range, but you can’t expect it to generalize to other inputs without retraining the model or adding more hidden neurons.
Unsupervised Learning
Training a model to find patterns in an unlabeled dataset (e.g. clustering).
Validation Set
A set of observations used during model training to provide feedback on how well the current parameters generalize beyond the training set. If training error decreases but validation error increases, your model is likely overfitting and you should pause training.
Variance

How tightly packed are your predictions for a particular observation relative to each other?

• Low variance suggests your model is internally consistent, with predictions varying little from each other after every iteration.
• High variance (with low bias) suggests your model may be overfitting and reading too deeply into the noise found in every training set.

References

## Calculus¶

### Introduction¶

You need to know some basic calculus in order to understand how functions change over time (derivatives), and to calculate the total amount of a quantity that accumulates over a time period (integrals). The language of calculus will allow you to speak precisely about the properties of functions and better understand their behaviour.

Normally taking a calculus course involves doing lots of tedious calculations by hand, but having the power of computers on your side can make the process much more fun. This section describes the key ideas of calculus which you’ll need to know to understand machine learning concepts.

### Derivatives¶

A derivative can be defined in two ways:

1. Instantaneous rate of change (Physics)
2. Slope of a line at a specific point (Geometry)

Both represent the same principle, but for our purposes it’s easier to explain using the geometric definition.

#### Geometric definition¶

In geometry slope represents the steepness of a line. It answers the question: how much does $$y$$ or $$f(x)$$ change given a specific change in $$x$$? Using this definition we can easily calculate the slope between two points. But what if I asked you, instead of the slope between two points, what is the slope at a single point on the line? In this case there isn’t any obvious «rise-over-run» to calculate. Derivatives help us answer this question.

A derivative outputs an expression we can use to calculate the instantaneous rate of change, or slope, at a single point on a line. After solving for the derivative you can use it to calculate the slope at every other point on the line.

#### Taking the derivative¶

Consider the graph below, where $$f(x) = x^2 + 3$$. The slope between (1,4) and (3,12) would be:

$slope = \frac{y2-y1}{x2-x1} = \frac{12-4}{3-1} = 4$

But how do we calculate the slope at point (1,4) to reveal the change in slope at that specific point?

One way would be to find the two nearest points, calculate their slopes relative to $$x$$ and take the average. But calculus provides an easier, more precise way: compute the derivative. Computing the derivative of a function is essentially the same as our original proposal, but instead of finding the two closest points, we make up an imaginary point an infinitesimally small distance away from $$x$$ and compute the slope between $$x$$ and the new point.

In this way, derivatives help us answer the question: how does $$f(x)$$ change if we make a very very tiny increase to x? In other words, derivatives help estimate the slope between two points that are an infinitesimally small distance away from each other. A very, very, very small distance, but large enough to calculate the slope.

In math language we represent this infinitesimally small increase using a limit. A limit is defined as the output value a function approaches as the input value approaches another value. In our case the target value is the specific point at which we want to calculate slope.

#### Step-by-step¶

Calculating the derivative is the same as calculating normal slope, however in this case we calculate the slope between our point and a point infinitesimally close to it. We use the variable $$h$$ to represent this infinitesimally distance. Here are the steps:

1. Given the function:
$f(x) = x^2$
1. Increment $$x$$ by a very small value $$h (h = Δx)$$
$f(x + h) = (x + h)^2$
1. Apply the slope formula
$\frac{f(x + h) - f(x)}{h}$
1. Simplify the equation
\begin{align}\begin{aligned}\begin{split}\frac{x^2 + 2xh + h^2 - x^2}{h} \\\end{split}\\\frac{2xh+h^2}{h} = 2x+h\end{aligned}\end{align}
1. Set $$h$$ to 0 (the limit as $$h$$ heads toward 0)
${2x + 0} = {2x}$

So what does this mean? It means for the function $$f(x) = x^2$$, the slope at any point equals $$2x$$. The formula is defined as:

$\lim_{h\to0}\frac{f(x+h) - f(x)}{h}$

Code

Let’s write code to calculate the derivative of any function $$f(x)$$. We test our function works as expected on the input $$f(x)=x^2$$ producing a value close to the actual derivative $$2x$$.

def get_derivative(func, x):
"""Compute the derivative of func at the location x."""
h = 0.0001                          # step size
return (func(x+h) - func(x)) / h    # rise-over-run

def f(x): return x**2                   # some test function f(x)=x^2
x = 3                                   # the location of interest
computed = get_derivative(f, x)
actual = 2*x

computed, actual   # = 6.0001, 6        # pretty close if you ask me...


In general it’s preferable to use the math to obtain exact derivative formulas, but keep in mind you can always compute derivatives numerically by computing the rise-over-run for a «small step» $$h$$.

#### Machine learning use cases¶

Machine learning uses derivatives in optimization problems. Optimization algorithms like gradient descent use derivatives to decide whether to increase or decrease weights in order to maximize or minimize some objective (e.g. a model’s accuracy or error functions). Derivatives also help us approximate nonlinear functions as linear functions (tangent lines), which have constant slopes. With a constant slope we can decide whether to move up or down the slope (increase or decrease our weights) to get closer to the target value (class label).

### Chain rule¶

The chain rule is a formula for calculating the derivatives of composite functions. Composite functions are functions composed of functions inside other function(s).

#### How It Works¶

Given a composite function $$f(x) = A(B(x))$$, the derivative of $$f(x)$$ equals the product of the derivative of $$A$$ with respect to $$B(x)$$ and the derivative of $$B$$ with respect to $$x$$.

$\mbox{composite function derivative} = \mbox{outer function derivative} * \mbox{inner function derivative}$

For example, given a composite function $$f(x)$$, where:

$f(x) = h(g(x))$

The chain rule tells us that the derivative of $$f(x)$$ equals:

$\frac{df}{dx} = \frac{dh}{dg} \cdot \frac{dg}{dx}$

#### Step-by-step¶

Say $$f(x)$$ is composed of two functions $$h(x) = x^3$$ and $$g(x) = x^2$$. And that:

\begin{split}\begin{align} f(x) &= h(g(x)) \\ &= (x^2)^3 \\ \end{align}\end{split}

The derivative of $$f(x)$$ would equal:

\begin{split}\begin{align} \frac{df}{dx} &= \frac{dh}{dg} \frac{dg}{dx} \\ &= \frac{dh}{d(x^2)} \frac{dg}{dx} \end{align}\end{split}

Steps

1. Solve for the inner derivative of $$g(x) = x^2$$
$\frac{dg}{dx} = 2x$
1. Solve for the outer derivative of $$h(x) = x^3$$, using a placeholder $$b$$ to represent the inner function $$x^2$$
$\frac{dh}{db} = 3b^2$
1. Swap out the placeholder variable for the inner function
$3x^4$
1. Return the product of the two derivatives
$3x^4 \cdot 2x = 6x^5$

#### Multiple functions¶

In the above example we assumed a composite function containing a single inner function. But the chain rule can also be applied to higher-order functions like:

$f(x) = A(B(C(x)))$

The chain rule tells us that the derivative of this function equals:

$\frac{df}{dx} = \frac{dA}{dB} \frac{dB}{dC} \frac{dC}{dx}$

We can also write this derivative equation $$f'$$ notation:

$f' = A'(B(C(x)) \cdot B'(C(x)) \cdot C'(x)$

Steps

Given the function $$f(x) = A(B(C(x)))$$, lets assume:

\begin{split}\begin{align} A(x) & = sin(x) \\ B(x) & = x^2 \\ C(x) & = 4x \end{align}\end{split}

The derivatives of these functions would be:

\begin{split}\begin{align} A'(x) &= cos(x) \\ B'(x) &= 2x \\ C'(x) &= 4 \end{align}\end{split}

We can calculate the derivative of $$f(x)$$ using the following formula:

$f'(x) = A'( (4x)^2) \cdot B'(4x) \cdot C'(x)$

We then input the derivatives and simplify the expression:

\begin{split}\begin{align} f'(x) &= cos((4x)^2) \cdot 2(4x) \cdot 4 \\ &= cos(16x^2) \cdot 8x \cdot 4 \\ &= cos(16x^2)32x \end{align}\end{split}

A gradient is a vector that stores the partial derivatives of multivariable functions. It helps us calculate the slope at a specific point on a curve for functions with multiple independent variables. In order to calculate this more complex slope, we need to isolate each variable to determine how it impacts the output on its own. To do this we iterate through each of the variables and calculate the derivative of the function after holding all other variables constant. Each iteration produces a partial derivative which we store in the gradient.

#### Partial derivatives¶

In functions with 2 or more variables, the partial derivative is the derivative of one variable with respect to the others. If we change $$x$$, but hold all other variables constant, how does $$f(x,z)$$ change? That’s one partial derivative. The next variable is $$z$$. If we change $$z$$ but hold $$x$$ constant, how does $$f(x,z)$$ change? We store partial derivatives in a gradient, which represents the full derivative of the multivariable function.

#### Step-by-step¶

Here are the steps to calculate the gradient for a multivariable function:

1. Given a multivariable function
$f(x,z) = 2z^3x^2$
1. Calculate the derivative with respect to $$x$$
$\frac{df}{dx}(x,z)$
1. Swap $$2z^3$$ with a constant value $$b$$
$f(x,z) = bx^2$
1. Calculate the derivative with $$b$$ constant
\begin{split}\begin{align} \frac{df}{dx} & = \lim_{h\to0}\frac{f(x+h) - f(x)}{h} \\ & = \lim_{h\to0}\frac{b(x+h)^2 - b(x^2)}{h} \\ & = \lim_{h\to0}\frac{b((x+h)(x+h)) - bx^2}{h} \\ & = \lim_{h\to0}\frac{b((x^2 + xh + hx + h^2)) - bx^2}{h} \\ & = \lim_{h\to0}\frac{bx^2 + 2bxh + bh^2 - bx^2}{h} \\ & = \lim_{h\to0}\frac{2bxh + bh^2}{h} \\ & = \lim_{h\to0}\frac{2bxh + bh^2}{h} \\ & = \lim_{h\to0} 2bx + bh \\ \end{align}\end{split}

As $$h —> 0$$

2bx + 0
1. Swap $$2z^3$$ back into the equation, to find the derivative with respect to $$x$$.
\begin{split}\begin{align} \frac{df}{dx}(x,z) &= 2(2z^3)x \\ &= 4z^3x \end{align}\end{split}
1. Repeat the above steps to calculate the derivative with respect to $$z$$
$\frac{df}{dz}(x,z) = 6x^2z^2$
1. Store the partial derivatives in a gradient
$\begin{split}\nabla f(x,z)=\begin{bmatrix} \frac{df}{dx} \\ \frac{df}{dz} \\ \end{bmatrix} =\begin{bmatrix} 4z^3x \\ 6x^2z^2 \\ \end{bmatrix}\end{split}$

#### Directional derivatives¶

Another important concept is directional derivatives. When calculating the partial derivatives of multivariable functions we use our old technique of analyzing the impact of infinitesimally small increases to each of our independent variables. By increasing each variable we alter the function output in the direction of the slope.

But what if we want to change directions? For example, imagine we’re traveling north through mountainous terrain on a 3-dimensional plane. The gradient we calculated above tells us we’re traveling north at our current location. But what if we wanted to travel southwest? How can we determine the steepness of the hills in the southwest direction? Directional derivatives help us find the slope if we move in a direction different from the one specified by the gradient.

Math

The directional derivative is computed by taking the dot product  of the gradient of $$f$$ and a unit vector $$\vec{v}$$ of «tiny nudges» representing the direction. The unit vector describes the proportions we want to move in each direction. The output of this calculation is a scalar number representing how much $$f$$ will change if the current input moves with vector $$\vec{v}$$.

Let’s say you have the function $$f(x,y,z)$$ and you want to compute its directional derivative along the following vector :

$\begin{split}\vec{v}=\begin{bmatrix} 2 \\ 3 \\ -1 \\ \end{bmatrix}\end{split}$

As described above, we take the dot product of the gradient and the directional vector:

$\begin{split}\begin{bmatrix} \frac{df}{dx} \\ \frac{df}{dy} \\ \frac{df}{dz} \\ \end{bmatrix} \cdot \begin{bmatrix} 2 \\ 3 \\ -1 \\ \end{bmatrix}\end{split}$

We can rewrite the dot product as:

$\nabla_\vec{v} f = 2 \frac{df}{dx} + 3 \frac{df}{dy} - 1 \frac{df}{dz}$

This should make sense because a tiny nudge along $$\vec{v}$$ can be broken down into two tiny nudges in the x-direction, three tiny nudges in the y-direction, and a tiny nudge backwards, by −1 in the z-direction.

#### Useful properties¶

There are two additional properties of gradients that are especially useful in deep learning. The gradient of a function:

1. Always points in the direction of greatest increase of a function (explained here)
2. Is zero at a local maximum or local minimum

### Integrals¶

The integral of $$f(x)$$ corresponds to the computation of the area under the graph of $$f(x)$$. The area under $$f(x)$$ between the points $$x=a$$ and $$x=b$$ is denoted as follows:

$A(a,b) = \int_a^b f(x) \: dx.$ The area $$A(a,b)$$ is bounded by the function $$f(x)$$ from above, by the $$x$$-axis from below, and by two vertical lines at $$x=a$$ and $$x=b$$. The points $$x=a$$ and $$x=b$$ are called the limits of integration. The $$\int$$ sign comes from the Latin word summa. The integral is the «sum» of the values of $$f(x)$$ between the two limits of integration.

The integral function $$F(c)$$ corresponds to the area calculation as a function of the upper limit of integration:

$F(c) \equiv \int_0^c \! f(x)\:dx\,.$

There are two variables and one constant in this formula. The input variable $$c$$ describes the upper limit of integration. The integration variable $$x$$ performs a sweep from $$x=0$$ until $$x=c$$. The constant $$0$$ describes the lower limit of integration. Note that choosing $$x=0$$ for the starting point of the integral function was an arbitrary choice.

The integral function $$F(c)$$ contains the «precomputed» information about the area under the graph of $$f(x)$$. The derivative function $$f'(x)$$ tells us the «slope of the graph» property of the function $$f(x)$$ for all values of $$x$$. Similarly, the integral function $$F(c)$$ tells us the «area under the graph» property of the function $$f(x)$$ for all possible limits of integration.

The area under $$f(x)$$ between $$x=a$$ and $$x=b$$ is obtained by calculating the change in the integral function as follows:

$A(a,b) = \int_a^b \! f(x)\:dx = F(b)-F(a).$ #### Computing integrals¶

We can approximate the total area under the function $$f(x)$$ between $$x=a$$ and $$x=b$$ by splitting the region into tiny vertical strips of width $$h$$, then adding up the areas of the rectangular strips. The figure below shows how to compute the area under $$f(x)=x^2$$ between $$x=1$$ and $$x=3$$ by approximating it as four rectangular strips of width $$h=0.5$$. Usually we want to choose $$h$$ to be a small number so that the approximation is accurate. Here is some sample code that performs integration.

def get_integral(func, a, b):
"""Compute the area under func between x=a and x=b."""
h = 0.0001               # width of small rectangle
x = a                    # start at x=a
total = 0
while x <= b:            # continue until x=b
total += h*func(x)   # area of rect is base*height
x += h

def f(x): return x**2                    # some test function f(x)=x^2
computed = get_integral(f, 1, 3)
def actualF(x): return 1.0/3.0*x**3
actual = actualF(3) - actualF(1)
computed, actual    # = 8.6662, 8.6666   # pretty close if you ask me...


You can find integral functions using the derivative formulas and some reverse engineering. To find an integral function of the function $$f(x)$$, we must find a function $$F(x)$$ such that $$F'(x)=f(x)$$. Suppose you’re given a function $$f(x)$$ and asked to find its integral function $$F(x)$$:

$F(x) = \int \! f(x)\: dx.$

This problem is equivalent to finding a function $$F(x)$$ whose derivative is $$f(x)$$:

$F'(x) = f(x).$

For example, suppose you want to find the indefinite integral $$\int \!x^2\:dx$$. We can rephrase this problem as the search for some function $$F(x)$$ such that

$F'(x) = x^2.$

Remembering the derivative formulas we saw above, you guess that $$F(x)$$ must contain an $$x^3$$ term. Taking the derivative of a cubic term results in a quadratic term. Therefore, the function you are looking for has the form $$F(x)=cx^3$$, for some constant $$c$$. Pick the constant $$c$$ that makes this equation true:

$F'(x) = 3cx^2 = x^2.$

Solving $$3c=1$$, we find $$c=\frac{1}{3}$$ and so the integral function is

$F(x) = \int x^2 \:dx = \frac{1}{3}x^3 + C.$

You can verify that $$\frac{d}{dx}\left[\frac{1}{3}x^3 + C\right] = x^2$$.

#### Applications of integration¶

Integral calculations have widespread applications to more areas of science than are practical to list here. Let’s explore a few examples related to probabilities.

##### Computing probabilities¶

A continuous random variable $$X$$ is described by its probability density function $$p(x)$$. A probability density function $$p(x)$$ is a positive function for which the total area under the curve is $$1$$:

$p(x) \geq 0, \forall x \qquad \textrm{and} \qquad \int_{-\infty}^\infty p(x)\; dx = 1.$

The probability of observing a value of $$X$$ between $$a$$ and $$b$$ is given by the integral

$\textrm{Pr}(a \leq X \leq b) = \int_a^b p(x)\; dx.$

Thus, the notion of integration is central to probability theory with continuous random variables.

We also use integration to compute certain characteristic properties of the random variable. The expected value and the variance are two properties of any random variable $$X$$ that capture important aspects of its behaviour.

##### Expected value¶

The expected value of the random variable $$X$$ is computed using the formula

$\mu % \equiv \mathbb{E}_X[X] = \int_{-\infty}^\infty x\, p(x).$

The expected value is a single number that tells us what value of $$X$$ we can expect to obtain on average from the random variable $$X$$. The expected value is also called the average or the mean of the random variable $$X$$.

##### Variance¶

The variance of the random variable $$X$$ is defined as follows:

$\sigma^2 % \equiv \mathbb{E}_X\!\big[(X-\mu)^2\big] = \int_{-\infty}^\infty (x-\mu)^2 \, p(x).$

The variance formula computes the expectation of the squared distance of the random variable $$X$$ from its expected value. The variance $$\sigma^2$$, also denoted $$\textrm{var}(X)$$, gives us an indication of how clustered or spread the values of $$X$$ are. A small variance indicates the outcomes of $$X$$ are tightly clustered near the expected value $$\mu$$, while a large variance indicates the outcomes of $$X$$ are widely spread. The square root of the variance is called the standard deviation and is usually denoted $$\sigma$$.

The expected value $$\mu$$ and the variance $$\sigma^2$$ are two central concepts in probability theory and statistics because they allow us to characterize any random variable. The expected value is a measure of the central tendency of the random variable, while the variance $$\sigma^2$$ measures its dispersion. Readers familiar with concepts from physics can think of the expected value as the centre of mass of the distribution, and the variance as the moment of inertia of the distribution.

References

## Linear Algebra¶

Linear algebra is a mathematical toolbox that offers helpful techniques for manipulating groups of numbers simultaneously. It provides structures like vectors and matrices (spreadsheets) to hold these numbers and new rules for how to add, subtract, multiply, and divide them. Here is a brief overview of basic linear algebra concepts taken from my linear algebra post on Medium.

### Vectors¶

Vectors are 1-dimensional arrays of numbers or terms. In geometry, vectors store the magnitude and direction of a potential change to a point. The vector [3, -2] says go right 3 and down 2. A vector with more than one dimension is called a matrix.

#### Notation¶

There are a variety of ways to represent vectors. Here are a few you might come across in your reading.

$\begin{split}v = \begin{bmatrix} 1 \\ 2 \\ 3 \\ \end{bmatrix} = \begin{pmatrix} 1 \\ 2 \\ 3 \\ \end{pmatrix} = \begin{bmatrix} 1 & 2 & 3\\ \end{bmatrix}\end{split}$

#### Vectors in geometry¶

Vectors typically represent movement from a point. They store both the magnitude and direction of potential changes to a point. The vector [-2,5] says move left 2 units and up 5 units . A vector can be applied to any point in space. The vector’s direction equals the slope of the hypotenuse created moving up 5 and left 2. Its magnitude equals the length of the hypotenuse.

#### Scalar operations¶

Scalar operations involve a vector and a number. You modify the vector in-place by adding, subtracting, or multiplying the number from all the values in the vector.

$\begin{split}\begin{bmatrix} 2 \\ 2 \\ 2 \\ \end{bmatrix} + 1 = \begin{bmatrix} 3 \\ 3 \\ 3 \\ \end{bmatrix}\end{split}$

#### Elementwise operations¶

In elementwise operations like addition, subtraction, and division, values that correspond positionally are combined to produce a new vector. The 1st value in vector A is paired with the 1st value in vector B. The 2nd value is paired with the 2nd, and so on. This means the vectors must have equal dimensions to complete the operation.*

$\begin{split}\begin{bmatrix} a_1 \\ a_2 \\ \end{bmatrix} + \begin{bmatrix} b_1 \\ b_2 \\ \end{bmatrix} = \begin{bmatrix} a_1+b_1 \\ a_2+b_2 \\ \end{bmatrix}\end{split}$
y = np.array([1,2,3])
x = np.array([2,3,4])
y + x = [3, 5, 7]
y - x = [-1, -1, -1]
y / x = [.5, .67, .75]


See below for details on broadcasting in numpy.

#### Dot product¶

The dot product of two vectors is a scalar. Dot product of vectors and matrices (matrix multiplication) is one of the most important operations in deep learning.

$\begin{split}\begin{bmatrix} a_1 \\ a_2 \\ \end{bmatrix} \cdot \begin{bmatrix} b_1 \\ b_2 \\ \end{bmatrix} = a_1 b_1+a_2 b_2\end{split}$
y = np.array([1,2,3])
x = np.array([2,3,4])
np.dot(y,x) = 20


Hadamard Product is elementwise multiplication and it outputs a vector.

$\begin{split}\begin{bmatrix} a_1 \\ a_2 \\ \end{bmatrix} \odot \begin{bmatrix} b_1 \\ b_2 \\ \end{bmatrix} = \begin{bmatrix} a_1 \cdot b_1 \\ a_2 \cdot b_2 \\ \end{bmatrix}\end{split}$
y = np.array([1,2,3])
x = np.array([2,3,4])
y * x = [2, 6, 12]


#### Vector fields¶

A vector field shows how far the point (x,y) would hypothetically move if we applied a vector function to it like addition or multiplication. Given a point in space, a vector field shows the power and direction of our proposed change at a variety of points in a graph . This vector field is an interesting one since it moves in different directions depending the starting point. The reason is that the vector behind this field stores terms like $$2x$$ or $$x^2$$ instead of scalar values like -2 and 5. For each point on the graph, we plug the x-coordinate into $$2x$$ or $$x^2$$ and draw an arrow from the starting point to the new location. Vector fields are extremely useful for visualizing machine learning techniques like Gradient Descent.

### Matrices¶

A matrix is a rectangular grid of numbers or terms (like an Excel spreadsheet) with special rules for addition, subtraction, and multiplication.

#### Dimensions¶

We describe the dimensions of a matrix in terms of rows by columns.

$\begin{split}\begin{bmatrix} 2 & 4 \\ 5 & -7 \\ 12 & 5 \\ \end{bmatrix} \begin{bmatrix} a² & 2a & 8\\ 18 & 7a-4 & 10\\ \end{bmatrix}\end{split}$

The first has dimensions (3,2). The second (2,3).

a = np.array([
[1,2,3],
[4,5,6]
])
a.shape == (2,3)
b = np.array([
[1,2,3]
])
b.shape == (1,3)


#### Scalar operations¶

Scalar operations with matrices work the same way as they do for vectors. Simply apply the scalar to every element in the matrix — add, subtract, divide, multiply, etc.

$\begin{split}\begin{bmatrix} 2 & 3 \\ 2 & 3 \\ 2 & 3 \\ \end{bmatrix} + 1 = \begin{bmatrix} 3 & 4 \\ 3 & 4 \\ 3 & 4 \\ \end{bmatrix}\end{split}$
# Addition
a = np.array(
[[1,2],
[3,4]])
a + 1
[[2,3],
[4,5]]


#### Elementwise operations¶

In order to add, subtract, or divide two matrices they must have equal dimensions. We combine corresponding values in an elementwise fashion to produce a new matrix.

$\begin{split}\begin{bmatrix} a & b \\ c & d \\ \end{bmatrix} + \begin{bmatrix} 1 & 2\\ 3 & 4 \\ \end{bmatrix} = \begin{bmatrix} a+1 & b+2\\ c+3 & d+4 \\ \end{bmatrix}\end{split}$
a = np.array([
[1,2],
[3,4]])
b = np.array([
[1,2],
[3,4]])

a + b
[[2, 4],
[6, 8]]

a — b
[[0, 0],
[0, 0]]


Hadamard product of matrices is an elementwise operation. Values that correspond positionally are multiplied to produce a new matrix.

$\begin{split}\begin{bmatrix} a_1 & a_2 \\ a_3 & a_4 \\ \end{bmatrix} \odot \begin{bmatrix} b_1 & b_2 \\ b_3 & b_4 \\ \end{bmatrix} = \begin{bmatrix} a_1 \cdot b_1 & a_2 \cdot b_2 \\ a_3 \cdot b_3 & a_4 \cdot b_4 \\ \end{bmatrix}\end{split}$
a = np.array(
[[2,3],
[2,3]])
b = np.array(
[[3,4],
[5,6]])

# Uses python's multiply operator
a * b
[[ 6, 12],
[10, 18]]


In numpy you can take the Hadamard product of a matrix and vector as long as their dimensions meet the requirements of broadcasting.

$\begin{split}\begin{bmatrix} {a_1} \\ {a_2} \\ \end{bmatrix} \odot \begin{bmatrix} b_1 & b_2 \\ b_3 & b_4 \\ \end{bmatrix} = \begin{bmatrix} a_1 \cdot b_1 & a_1 \cdot b_2 \\ a_2 \cdot b_3 & a_2 \cdot b_4 \\ \end{bmatrix}\end{split}$

#### Matrix transpose¶

Neural networks frequently process weights and inputs of different sizes where the dimensions do not meet the requirements of matrix multiplication. Matrix transpose provides a way to “rotate” one of the matrices so that the operation complies with multiplication requirements and can continue. There are two steps to transpose a matrix:

1. Rotate the matrix right 90°
2. Reverse the order of elements in each row (e.g. [a b c] becomes [c b a])

As an example, transpose matrix M into T:

$\begin{split}\begin{bmatrix} a & b \\ c & d \\ e & f \\ \end{bmatrix} \quad \Rightarrow \quad \begin{bmatrix} a & c & e \\ b & d & f \\ \end{bmatrix}\end{split}$
a = np.array([
[1, 2],
[3, 4]])

a.T
[[1, 3],
[2, 4]]


#### Matrix multiplication¶

Matrix multiplication specifies a set of rules for multiplying matrices together to produce a new matrix.

Rules

Not all matrices are eligible for multiplication. In addition, there is a requirement on the dimensions of the resulting matrix output. Source.

1. The number of columns of the 1st matrix must equal the number of rows of the 2nd
2. The product of an M x N matrix and an N x K matrix is an M x K matrix. The new matrix takes the rows of the 1st and columns of the 2nd

Steps

Matrix multiplication relies on dot product to multiply various combinations of rows and columns. In the image below, taken from Khan Academy’s excellent linear algebra course, each entry in Matrix C is the dot product of a row in matrix A and a column in matrix B . The operation a1 · b1 means we take the dot product of the 1st row in matrix A (1, 7) and the 1st column in matrix B (3, 5).

$\begin{split}a_1 \cdot b_1 = \begin{bmatrix} 1 \\ 7 \\ \end{bmatrix} \cdot \begin{bmatrix} 3 \\ 5 \\ \end{bmatrix} = (1 \cdot 3) + (7 \cdot 5) = 38\end{split}$

Here’s another way to look at it:

$\begin{split}\begin{bmatrix} a & b \\ c & d \\ e & f \\ \end{bmatrix} \cdot \begin{bmatrix} 1 & 2 \\ 3 & 4 \\ \end{bmatrix} = \begin{bmatrix} 1a + 3b & 2a + 4b \\ 1c + 3d & 2c + 4d \\ 1e + 3f & 2e + 4f \\ \end{bmatrix}\end{split}$

#### Test yourself¶

1. What are the dimensions of the matrix product?
$\begin{split}\begin{bmatrix} 1 & 2 \\ 5 & 6 \\ \end{bmatrix} \cdot \begin{bmatrix} 1 & 2 & 3 \\ 5 & 6 & 7 \\ \end{bmatrix} = \text{2 x 3}\end{split}$
1. What are the dimensions of the matrix product?
$\begin{split}\begin{bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \\ \end{bmatrix} \cdot \begin{bmatrix} 1 & 2 \\ 5 & 6 \\ 3 & 0 \\ 2 & 1 \\ \end{bmatrix} = \text{3 x 2}\end{split}$
1. What is the matrix product?
$\begin{split}\begin{bmatrix} 2 & 3 \\ 1 & 4 \\ \end{bmatrix} \cdot \begin{bmatrix} 5 & 4 \\ 3 & 5 \\ \end{bmatrix} = \begin{bmatrix} 19 & 23 \\ 17 & 24 \\ \end{bmatrix}\end{split}$
1. What is the matrix product?}
$\begin{split}\begin{bmatrix} 3 \\ 5 \\ \end{bmatrix} \cdot \begin{bmatrix} 1 & 2 & 3\\ \end{bmatrix} = \begin{bmatrix} 3 & 6 & 9 \\ 5 & 10 & 15 \\ \end{bmatrix}\end{split}$
1. What is the matrix product?
$\begin{split}\begin{bmatrix} 1 & 2 & 3\\ \end{bmatrix} \cdot \begin{bmatrix} 4 \\ 5 \\ 6 \\ \end{bmatrix} = \begin{bmatrix} 32 \\ \end{bmatrix}\end{split}$

### Numpy¶

#### Dot product¶

Numpy uses the function np.dot(A,B) for both vector and matrix multiplication. It has some other interesting features and gotchas so I encourage you to read the documentation here before use.

a = np.array([
[1, 2]
])
a.shape == (1,2)
b = np.array([
[3, 4],
[5, 6]
])
b.shape == (2,2)

# Multiply
mm = np.dot(a,b)
mm == [13, 16]
mm.shape == (1,2)


In numpy the dimension requirements for elementwise operations are relaxed via a mechanism called broadcasting. Two matrices are compatible if the corresponding dimensions in each matrix (rows vs rows, columns vs columns) meet the following requirements:

1. The dimensions are equal, or
2. One dimension is of size 1
a = np.array([
,

])
b = np.array([
[3,4],
[5,6]
])
c = np.array([
[1,2]
])

# Same no. of rows
# Different no. of columns
# but a has one column so this works
a * b
[[ 3, 4],
[10, 12]]

# Same no. of columns
# Different no. of rows
# but c has one row so this works
b * c
[[ 3, 8],
[5, 12]]

# Different no. of columns
# Different no. of rows
# but both a and c meet the
# size 1 requirement rule
a + c
[[2, 3],
[3, 4]]


Tutorials

References

## Probability¶

Basic concepts in probability for machine learning.

References

  Example

## Statistics¶

Basic concepts in statistics for machine learning.

References

  Example

## Notation¶

Commonly used math symbols in machine learning texts.

Примечание

Use the table generator to quickly add new symbols. Import current tables into tablesgenerator from figures/*.tgn. Export and save your changes. Also see helpful multiline editing in Sublime.

### Algebra¶

 Symbol Name Description Example $$(f ∘ g)$$ composite function a nested function (f ∘ g)(x) = f(g(x)) $$∆$$ delta change / difference ∆x = x_1 - x_0 $$e$$ Euler’s number e = 2.718281828 s = frac{1}{1+e^{-z}} $$\sum$$ summation sum of all values ∑ x_i = x_1 + x_2 + x_3 $$\prod$$ capital pi product of all values ∏ x_i = x_1∙x_2∙x_3 $$\epsilon$$ epsilon tiny number near 0 lr = 1e-4

### Calculus¶

 Symbol Name Description Example $$x'$$ derivative first derivative (x^2)“ = 2x $$x''$$ second derivative second derivative (x^2)““ = 2 $$\lim$$ limit function value as x approaches 0 $$∇$$ nabla gradient ∇f(a,b,c)

### Linear algebra¶

 Symbol Name Description Example $$[ ]$$ brackets matrix or vector $$M = [1 3 5]$$ $$\cdot$$ dot dot product $$(Z = X \cdot W$$ $$\odot$$ hadamard hadamard product $$A = B \odot C$$ $$X^T$$ transpose matrix transpose $$W^T \cdot X$$ $$\vec x$$ vector vector $$v = [1 2 3]$$ $$X$$ matrix capitalized variables are matrices $$X, W, B$$ $$\hat x$$ unit vector vector of magnitude 1 $$\hat x = [0.2 0.5 0.3]$$

### Probability¶

 Symbol Name Description Example $$P(A)$$ probability probability of event A P(x=1) = 0.5

### Set theory¶

 Symbol Name Description Example $${ }$$ set list of distinct elements S = {1, 5, 7, 9}

### Statistics¶

 Symbol Name Description Example $$μ$$ population mean mean of population values $$\bar x$$ sample mean mean of subset of population $$σ^2$$ population variance variance of population value $$s^2$$ sample variance variance of subset of population $$σ_X$$ standard deviation population standard deviation $$s$$ sample std dev standard deviation of sample $$ρX$$ correlation correlation of variables X and Y $$\tilde x$$ median median value of variable x

References

## Основы¶

### Нейронная сеть (Neural network)¶

Neural networks are a class of machine learning algorithms used to model complex patterns in datasets using multiple hidden layers and non-linear activation functions. A neural network takes an input, passes it through multiple layers of hidden neurons (mini-functions with unique coefficients that must be learned), and outputs a prediction representing the combined input of all the neurons. Neural networks are trained iteratively using optimization techniques like gradient descent. After each cycle of training, an error metric is calculated based on the difference between prediction and target. The derivatives of this error metric are calculated and propagated back through the network using a technique called backpropagation. Each neuron’s coefficients (weights) are then adjusted relative to how much they contributed to the total error. This process is repeated iteratively until the network error drops below an acceptable threshold.

### Нейрон (Neuron)¶

A neuron takes a group of weighted inputs, applies an activation function, and returns an output. Inputs to a neuron can either be features from a training set or outputs from a previous layer’s neurons. Weights are applied to the inputs as they travel along synapses to reach the neuron. The neuron then applies an activation function to the “sum of weighted inputs” from each incoming synapse and passes the result on to all the neurons in the next layer.

### Синапсы (Synapses)¶

Synapses are like roads in a neural network. They connect inputs to neurons, neurons to neurons, and neurons to outputs. In order to get from one neuron to another, you have to travel along the synapse paying the “toll” (weight) along the way. Each connection between two neurons has a unique synapse with a unique weight attached to it. When we talk about updating weights in a network, we’re really talking about adjusting the weights on these synapses.

### Веса (Weights)¶

Explanation of weights (parameters)

### Смещение (Bias)¶

Bias terms are additional constants attached to neurons and added to the weighted input before the activation function is applied. Bias terms help models represent patterns that do not necessarily pass through the origin. For example, if all your features were 0, would your output also be zero? Is it possible there is some base value upon which your features have an effect? Bias terms typically accompany weights and must also be learned by your model.

### Layers¶ Input Layer

Holds the data your model will train on. Each neuron in the input layer represents a unique attribute in your dataset (e.g. height, hair color, etc.).

Hidden Layer

Sits between the input and output layers and applies an activation function before passing on the results. There are often multiple hidden layers in a network. In traditional networks, hidden layers are typically fully-connected layers — each neuron receives input from all the previous layer’s neurons and sends its output to every neuron in the next layer. This contrasts with how convolutional layers work where the neurons send their output to only some of the neurons in the next layer.

Output Layer

The final layer in a network. It receives input from the previous hidden layer, optionally applies an activation function, and returns an output representing your model’s prediction.

### Взвешенный вход (Weighted Input)¶

A neuron’s input equals the sum of weighted outputs from all neurons in the previous layer. Each input is multiplied by the weight associated with the synapse connecting the input to the current neuron. If there are 3 inputs or neurons in the previous layer, each neuron in the current layer will have 3 distinct weights — one for each each synapse.

Single Input

$\begin{split}Z &= Input \cdot Weight \\ &= X W\end{split}$

Multiple Inputs

$\begin{split}Z &= \sum_{i=1}^{n}x_i w_i \\ &= x_1 w_1 + x_2 w_2 + x_3 w_3\end{split}$

Notice, it’s exactly the same equation we use with linear regression! In fact, a neural network with a single neuron is the same as linear regression! The only difference is the neural network post-processes the weighted input with an activation function.

### Функции Активации¶

Activation functions live inside neural network layers and modify the data they receive before passing it to the next layer. Activation functions give neural networks their power — allowing them to model complex non-linear relationships. By modifying inputs with non-linear functions neural networks can model highly complex relationships between features. Popular activation functions include relu and sigmoid.

Activation functions typically have the following properties:

• Non-linear - In linear regression we’re limited to a prediction equation that looks like a straight line. This is nice for simple datasets with a one-to-one relationship between inputs and outputs, but what if the patterns in our dataset were non-linear? (e.g. $$x^2$$, sin, log). To model these relationships we need a non-linear prediction equation.¹ Activation functions provide this non-linearity.
• Continuously differentiable — To improve our model with gradient descent, we need our output to have a nice slope so we can compute error derivatives with respect to weights. If our neuron instead outputted 0 or 1 (perceptron), we wouldn’t know in which direction to update our weights to reduce our error.
• Fixed Range — Activation functions typically squash the input data into a narrow range that makes training the model more stable and efficient.

### Функции потерь (ошибки)¶

A loss function, or cost function, is a wrapper around our model’s predict function that tells us «how good» the model is at making predictions for a given set of parameters. The loss function has its own curve and its own derivatives. The slope of this curve tells us how to change our parameters to make the model more accurate! We use the model to make predictions. We use the cost function to update our parameters. Our cost function can take a variety of forms as there are many different cost functions available. Popular loss functions include: MSE (L2) and Cross-entropy Loss.

### Оптимизационные алгоритмы¶

Be the first to contribute!

References

## Прямое распространение¶

### Простая сеть¶ Прямое распространение - это процесс с помощью которого сеть делает предсказание (prediction). Также это основной режим работы обученной нейронной сети. Входные данные «распространяются» через каждый слой сети и выходной слой выдает финальный результат - предсказание. Для простой учебной нейронной сети один проход данных можно выразить математически как:

$Prediction = A(\;A(\;X W_h\;)W_o\;)$

Где $$A$$ это функция активации, например ReLU, $$X$$ это входные данные, $$W_h$$ и $$W_o$$ это веса слоев.

#### Прямой проход по шагам¶

1. Вычислить значения входов скрытого слоя умножениием $$X$$ на веса скрытого слоя $$W_h$$ и получить $$Z_h$$.
2. Применить функцию активации к $$Z_h$$ и передать результат $$H$$ в выходной слой.
3. Вычислить значения входов выходного слоя умножением значения $$H$$ на веса выходного слоя $$W_o$$ и получить $$Z_o$$
4. Применить функцию активации к $$Z_o$$. Результатом будет предсказание сети.

#### Код¶

Давайте напишем метод feed_forward() для распространения входных данных через нейронную сеть с 1-м скрытым слоем. Выход этого метода будет представлять собой предсказание модели.

def relu(z):
return max(0,z)

def feed_forward(x, Wh, Wo):
# Hidden layer
Zh = x * Wh
H = relu(Zh)

# Output layer
Zo = H * Wo
output = relu(Zo)
return output


x это вход сети, Zo и Zh это «взвешенный» вход слоев, a Wo и Wh это веса слоев.

### Более сложная сеть¶

Простая сеть очень помогает в учебном процессе, но реальные сети намного больше и сложнее устроены. Современные нейронные сети имеют гораздо больше скрытых слоев, больше нейронов в каждом слое, больше входных переменных. Рассмотрим более крупную (но всё ещё простую) нейронную сеть, которая позволит нам показать универсальный подход, основанный на матричном умножении, используемом в больших, «промышленных» нейронных сетях. #### Архитектура¶

Для произвольного изменения количества входов или выходов сети, мы должны сделать наш код более гибким с помощью добавления новых параметров в __init_ метод: inputLayerSize, hiddenLayerSize,outputLayerSize. Мы будем продолжать ограничивать себя в количестве скрытых слоев, но сейчас это не так важно, потому что мы можем менять ширину (количество нейронов) имеющихся слоев.

INPUT_LAYER_SIZE = 1
HIDDEN_LAYER_SIZE = 2
OUTPUT_LAYER_SIZE = 2


#### Инициализация весов¶

Unlike last time where Wh and Wo were scalar numbers, our new weight variables will be numpy arrays. Each array will hold all the weights for its own layer — one weight for each synapse. Below we initialize each array with the numpy’s np.random.randn(rows, cols) method, which returns a matrix of random numbers drawn from a normal distribution with mean 0 and variance 1.

def init_weights():
Wh = np.random.randn(INPUT_LAYER_SIZE, HIDDEN_LAYER_SIZE) * \
np.sqrt(2.0/INPUT_LAYER_SIZE)
Wo = np.random.randn(HIDDEN_LAYER_SIZE, OUTPUT_LAYER_SIZE) * \
np.sqrt(2.0/HIDDEN_LAYER_SIZE)


Here’s an example calling random.randn():

arr = np.random.randn(1, 2)

print(arr)
>> [[-0.36094661 -1.30447338]]

print(arr.shape)
>> (1,2)


As you’ll soon see, there are strict requirements on the dimensions of these weight matrices. The number of rows must equal the number of neurons in the previous layer. The number of columns must match the number of neurons in the next layer.

A good explanation of random weight initalization can be found in the Stanford CS231 course notes  chapter on neural networks.

#### Bias Terms¶

Смещение (Bias) terms allow us to shift our neuron’s activation outputs left and right. This helps us model datasets that do not necessarily pass through the origin.

Using the numpy method np.full() below, we create two 1-dimensional bias arrays filled with the default value 0.2. The first argument to np.full is a tuple of array dimensions. The second is the default value for cells in the array.

def init_bias():
Bh = np.full((1, HIDDEN_LAYER_SIZE), 0.1)
Bo = np.full((1, OUTPUT_LAYER_SIZE), 0.1)
return Bh, Bo


#### Working with Matrices¶

To take advantage of fast linear algebra techniques and GPUs, we need to store our inputs, weights, and biases in matrices. Here is our neural network diagram again with its underlying matrix representation. What’s happening here? To better understand, let’s walk through each of the matrices in the diagram with an emphasis on their dimensions and why the dimensions are what they are. The matrix dimensions above flow naturally from the architecture of our network and the number of samples in our training set.

Matrix dimensions

 Var Name Dimensions Explanation X Input (3, 1) Includes 3 rows of training data, and each row has 1 attribute (height, price, etc.) Wh Hidden weights (1, 2) These dimensions are based on number of rows equals the number of attributes for the observations in our training set. The number columns equals the number of neurons in the hidden layer. The dimensions of the weights matrix between two layers is determined by the sizes of the two layers it connects. There is one weight for every input-to-neuron connection between the layers. Bh Hidden bias (1, 2) Each neuron in the hidden layer has is own bias constant. This bias matrix is added to the weighted input matrix before the hidden layer applies ReLU. Zh Hidden weighted input (1, 2) Computed by taking the dot product of X and Wh. The dimensions (1,2) are required by the rules of matrix multiplication. Zh takes the rows of in the inputs matrix and the columns of weights matrix. We then add the hidden layer bias matrix Bh. H Hidden activations (3, 2) Computed by applying the Relu function to Zh. The dimensions are (3,2) — the number of rows matches the number of training samples and the number of columns equals the number of neurons. Each column holds all the activations for a specific neuron. Wo Output weights (2, 2) The number of rows matches the number of hidden layer neurons and the number of columns equals the number of output layer neurons. There is one weight for every hidden-neuron-to-output-neuron connection between the layers. Bo Output bias (1, 2) There is one column for every neuron in the output layer. Zo Output weighted input (3, 2) Computed by taking the dot product of H and Wo and then adding the output layer bias Bo. The dimensions are (3,2) representing the rows of in the hidden layer matrix and the columns of output layer weights matrix. O Output activations (3, 2) Each row represents a prediction for a single observation in our training set. Each column is a unique attribute we want to predict. Examples of two-column output predictions could be a company’s sales and units sold, or a person’s height and weight.

#### Dynamic Resizing¶

Before we continue I want to point out how the matrix dimensions change with changes to the network architecture or size of the training set. For example, let’s build a network with 2 input neurons, 3 hidden neurons, 2 output neurons, and 4 observations in our training set. Now let’s use same number of layers and neurons but reduce the number of observations in our dataset to 1 instance: As you can see, the number of columns in all matrices remains the same. The only thing that changes is the number of rows the layer matrices, which fluctuate with the size of the training set. The dimensions of the weight matrices remain unchanged. This shows us we can use the same network, the same lines of code, to process any number of observations.

#### Refactoring Our Code¶

Here is our new feed forward code which accepts matrices instead of scalar inputs.

def feed_forward(X):
'''
X    - input matrix
Zh   - hidden layer weighted input
Zo   - output layer weighted input
H    - hidden layer activation
y    - output layer
yHat - output layer predictions
'''

# Hidden layer
Zh = np.dot(X, Wh) + Bh
H = relu(Zh)

# Output layer
Zo = np.dot(H, Wo) + Bo
yHat = relu(Zo)
return yHat


Weighted input

The first change is to update our weighted input calculation to handle matrices. Using dot product, we multiply the input matrix by the weights connecting them to the neurons in the next layer. Next we add the bias vector using matrix addition.

Zh = np.dot(X, Wh) + Bh The first column in Bh is added to all the rows in the first column of resulting dot product of X and Wh. The second value in Bh is added to all the elements in the second column. The result is a new matrix, Zh which has a column for every neuron in the hidden layer and a row for every observation in our dataset. Given all the layers in our network are fully-connected, there is one weight for every neuron-to-neuron connection between the layers.

The same process is repeated for the output layer, except the input is now the hidden layer activation H and the weights Wo.

ReLU activation

The second change is to refactor ReLU to use elementwise multiplication on matrices. It’s only a small change, but its necessary if we want to work with matrices. np.maximum() is actually extensible and can handle both scalar and array inputs.

def relu(Z):
return np.maximum(0, Z)


In the hidden layer activation step, we apply the ReLU activation function np.maximum(0,Z) to every cell in the new matrix. The result is a matrix where all negative values have been replaced by 0. The same process is repeated for the output layer, except the input is Zo.

#### Final Result¶

Putting it all together we have the following code for forward propagation with matrices.

INPUT_LAYER_SIZE = 1
HIDDEN_LAYER_SIZE = 2
OUTPUT_LAYER_SIZE = 2

def init_weights():
Wh = np.random.randn(INPUT_LAYER_SIZE, HIDDEN_LAYER_SIZE) * \
np.sqrt(2.0/INPUT_LAYER_SIZE)
Wo = np.random.randn(HIDDEN_LAYER_SIZE, OUTPUT_LAYER_SIZE) * \
np.sqrt(2.0/HIDDEN_LAYER_SIZE)

def init_bias():
Bh = np.full((1, HIDDEN_LAYER_SIZE), 0.1)
Bo = np.full((1, OUTPUT_LAYER_SIZE), 0.1)
return Bh, Bo

def relu(Z):
return np.maximum(0, Z)

def relu_prime(Z):
'''
Z - weighted input matrix

Returns gradient of Z where all
negative values are set to 0 and
all positive values set to 1
'''
Z[Z < 0] = 0
Z[Z > 0] = 1
return Z

def cost(yHat, y):
cost = np.sum((yHat - y)**2) / 2.0
return cost

def cost_prime(yHat, y):
return yHat - y

def feed_forward(X):
'''
X    - input matrix
Zh   - hidden layer weighted input
Zo   - output layer weighted input
H    - hidden layer activation
y    - output layer
yHat - output layer predictions
'''

# Hidden layer
Zh = np.dot(X, Wh) + Bh
H = relu(Zh)

# Output layer
Zo = np.dot(H, Wo) + Bo
yHat = relu(Zo)


References

## Backpropagation¶

The goals of backpropagation are straightforward: adjust each weight in the network in proportion to how much it contributes to overall error. If we iteratively reduce each weight’s error, eventually we’ll have a series of weights the produce good predictions.

### Chain rule refresher¶

As seen above, foward propagation can be viewed as a long series of nested equations. If you think of feed forward this way, then backpropagation is merely an application the Chain rule to find the Derivatives of cost with respect to any variable in the nested equation. Given a forward propagation function:

$f(x) = A(B(C(x)))$

A, B, and C are activation functions at different layers. Using the chain rule we easily calculate the derivative of $$f(x)$$ with respect to $$x$$:

$f'(x) = f'(A) \cdot A'(B) \cdot B'(C) \cdot C'(x)$

How about the derivative with respect to B? To find the derivative with respect to B you can pretend $$B(C(x))$$ is a constant, replace it with a placeholder variable B, and proceed to find the derivative normally with respect to B.

$f'(B) = f'(A) \cdot A'(B)$

This simple technique extends to any variable within a function and allows us to precisely pinpoint the exact impact each variable has on the total output.

### Applying the chain rule¶

Let’s use the chain rule to calculate the derivative of cost with respect to any weight in the network. The chain rule will help us identify how much each weight contributes to our overall error and the direction to update each weight to reduce our error. Here are the equations we need to make a prediction and calculate total error, or cost: Given a network consisting of a single neuron, total cost could be calculated as:

$Cost = C(R(Z(X W)))$

Using the chain rule we can easily find the derivative of Cost with respect to weight W.

$\begin{split}C'(W) &= C'(R) \cdot R'(Z) \cdot Z'(W) \\ &= (\hat{y} -y) \cdot R'(Z) \cdot X\end{split}$

Now that we have an equation to calculate the derivative of cost with respect to any weight, let’s go back to our toy neural network example above What is the derivative of cost with respect to $$W_o$$?

$\begin{split}C'(W_O) &= C'(\hat{y}) \cdot \hat{y}'(Z_O) \cdot Z_O'(W_O) \\ &= (\hat{y} - y) \cdot R'(Z_O) \cdot H\end{split}$

And how about with respect to $$W_h$$? To find out we just keep going further back in our function applying the chain rule recursively until we get to the function that has the Wh term.

$\begin{split}C'(W_h) &= C'(\hat{y}) \cdot O'(Z_o) \cdot Z_o'(H) \cdot H'(Z_h) \cdot Z_h'(W_h) \\ &= (\hat{y} - y) \cdot R'(Z_o) \cdot W_o \cdot R'(Z_h) \cdot X\end{split}$

And just for fun, what if our network had 10 hidden layers. What is the derivative of cost for the first weight $$w_1$$?

$\begin{split}C'(w_1) = \frac{dC}{d\hat{y}} \cdot \frac{d\hat{y}}{dZ_{11}} \cdot \frac{dZ_{11}}{dH_{10}} \cdot \\ \frac{dH_{10}}{dZ_{10}} \cdot \frac{dZ_{10}}{dH_9} \cdot \frac{dH_9}{dZ_9} \cdot \frac{dZ_9}{dH_8} \cdot \frac{dH_8}{dZ_8} \cdot \frac{dZ_8}{dH_7} \cdot \frac{dH_7}{dZ_7} \cdot \\ \frac{dZ_7}{dH_6} \cdot \frac{dH_6}{dZ_6} \cdot \frac{dZ_6}{dH_5} \cdot \frac{dH_5}{dZ_5} \cdot \frac{dZ_5}{dH_4} \cdot \frac{dH_4}{dZ_4} \cdot \frac{dZ_4}{dH_3} \cdot \\ \frac{dH_3}{dZ_3} \cdot \frac{dZ_3}{dH_2} \cdot \frac{dH_2}{dZ_2} \cdot \frac{dZ_2}{dH_1} \cdot \frac{dH_1}{dZ_1} \cdot \frac{dZ_1}{dW_1}\end{split}$

See the pattern? The number of calculations required to compute cost derivatives increases as our network grows deeper. Notice also the redundancy in our derivative calculations. Each layer’s cost derivative appends two new terms to the terms that have already been calculated by the layers above it. What if there was a way to save our work somehow and avoid these duplicate calculations?

### Saving work with memoization¶

Memoization is a computer science term which simply means: don’t recompute the same thing over and over. In memoization we store previously computed results to avoid recalculating the same function. It’s handy for speeding up recursive functions of which backpropagation is one. Notice the pattern in the derivative equations below. Each of these layers is recomputing the same derivatives! Instead of writing out long derivative equations for every weight, we can use memoization to save our work as we backprop error through the network. To do this, we define 3 equations (below), which together encapsulate all the calculations needed for backpropagation. The math is the same, but the equations provide a nice shorthand we can use to track which calculations we’ve already performed and save our work as we move backwards through the network. We first calculate the output layer error and pass the result to the hidden layer before it. After calculating the hidden layer error, we pass its error value back to the previous hidden layer before it. And so on and so forth. As we move back through the network we apply the 3rd formula at every layer to calculate the derivative of cost with respect that layer’s weights. This resulting derivative tells us in which direction to adjust our weights to reduce overall cost.

Примечание

The term layer error refers to the derivative of cost with respect to a layer’s input. It answers the question: how does the cost function output change when the input to that layer changes?

Output layer error

To calculate output layer error we need to find the derivative of cost with respect to the output layer input, $$Z_o$$. It answers the question — how are the final layer’s weights impacting overall error in the network? The derivative is then:

$C'(Z_o) = (\hat{y} - y) \cdot R'(Z_o)$

To simplify notation, ml practitioners typically replace the $$(\hat{y}-y) * R'(Zo)$$ sequence with the term $$E_o$$. So our formula for output layer error equals:

$E_o = (\hat{y} - y) \cdot R'(Z_o)$

Hidden layer error

To calculate hidden layer error we need to find the derivative of cost with respect to the hidden layer input, Zh.

$C'(Z_h) = (\hat{y} - y) \cdot R'(Z_o) \cdot W_o \cdot R'(Z_h)$

Next we can swap in the $$E_o$$ term above to avoid duplication and create a new simplified equation for Hidden layer error:

$E_h = E_o \cdot W_o \cdot R'(Z_h)$

This formula is at the core of backpropagation. We calculate the current layer’s error, and pass the weighted error back to the previous layer, continuing the process until we arrive at our first hidden layer. Along the way we update the weights using the derivative of cost with respect to each weight.

Derivative of cost with respect to any weight

Let’s return to our formula for the derivative of cost with respect to the output layer weight $$W_o$$.

$C'(W_O) = (\hat{y} - y) \cdot R'(Z_O) \cdot H$

We know we can replace the first part with our equation for output layer error $$E_h$$. H represents the hidden layer activation.

$C'(W_o) = E_o \cdot H$

So to find the derivative of cost with respect to any weight in our network, we simply multiply the corresponding layer’s error times its input (the previous layer’s output).

$C'(w) = CurrentLayerError \cdot CurrentLayerInput$

Примечание

Input refers to the activation from the previous layer, not the weighted input, Z.

Summary

Here are the final 3 equations that together form the foundation of backpropagation. Here is the process visualized using our toy neural network example above. ### Code example¶

def relu_prime(z):
if z > 0:
return 1
return 0

def cost(yHat, y):
return 0.5 * (yHat - y)**2

def cost_prime(yHat, y):
return yHat - y

def backprop(x, y, Wh, Wo, lr):
yHat = feed_forward(x, Wh, Wo)

# Layer Error
Eo = (yHat - y) * relu_prime(Zo)
Eh = Eo * Wo * relu_prime(Zh)

# Cost derivative for weights
dWo = Eo * H
dWh = Eh * x

# Update weights
Wh -= lr * dWh
Wo -= lr * dWo


References

  Example

## Activation Functions¶

### ELU¶

Be the first to contribute!

### ReLU¶

A recent invention which stands for Rectified Linear Units. The formula is deceptively simple: $$max(0,z)$$. Despite its name and appearance, it’s not linear and provides the same benefits as Sigmoid but with better performance.

 Function Derivative $\begin{split}R(z) = \begin{Bmatrix} z & z > 0 \\ 0 & z <= 0 \end{Bmatrix}\end{split}$ $\begin{split}R'(z) = \begin{Bmatrix} 1 & z>0 \\ 0 & z<0 \end{Bmatrix}\end{split}$  Pros

• Pro 1

Cons

• Con 1

### LeakyReLU¶

LeakyRelu is a variant of ReLU. Instead of being 0 when $$z < 0$$, a leaky ReLU allows a small, non-zero, constant gradient $$\alpha$$ (Normally, $$\alpha = 0.01$$). However, the consistency of the benefit across tasks is presently unclear. 

 Function Derivative $\begin{split}R(z) = \begin{Bmatrix} z & z > 0 \\ \alpha z & z <= 0 \end{Bmatrix}\end{split}$ $\begin{split}R'(z) = \begin{Bmatrix} 1 & z>0 \\ \alpha & z<0 \end{Bmatrix}\end{split}$  Pros

• Pro 1

Cons

• Con 1

### Sigmoid¶

Sigmoid takes a real value as input and outputs another value between 0 and 1. It’s easy to work with and has all the nice properties of activation functions: it’s non-linear, continuously differentiable, monotonic, and has a fixed output range.

 Function Derivative $S(z) = \frac{1} {1 + e^{-z}}$ $S'(z) = S(z) \cdot (1 - S(z))$  Pros

• Pro 1

Cons

• Con 1

### Tanh¶

Tanh squashes a real-valued number to the range [-1, 1]. It’s non-linear. But unlike Sigmoid, its output is zero-centered. Therefore, in practice the tanh non-linearity is always preferred to the sigmoid nonlinearity. 

 Function Derivative $tanh(z) = \frac{e^{z} - e^{-z}}{e^{z} + e^{-z}}$ $tanh'(z) = 1 - tanh(z)^{2}$  Pros

• Pro 1

Cons

• Con 1

### Softmax¶

Be the first to contribute!

References

## Layers¶

### BatchNorm¶

BatchNorm accelerates convergence by reducing internal covariate shift inside each batch. If the individual observations in the batch are widely different, the gradient updates will be choppy and take longer to converge.

The batch norm layer normalizes the incoming activations and outputs a new batch where the mean equals 0 and standard deviation equals 1. It subtracts the mean and divides by the standard deviation of the batch.

Code

def BatchNorm():
# From https://wiseodd.github.io/techblog/2016/07/04/batchnorm/
def __init__(self):
pass

def forward(self, X, gamma, beta):
mu = np.mean(X, axis=0)
var = np.var(X, axis=0)

X_norm = (X - mu) / np.sqrt(var + 1e-8)
out = gamma * X_norm + beta

cache = (X, X_norm, mu, var, gamma, beta)

return out, cache, mu, var

def backward(self, dout, cache):
X, X_norm, mu, var, gamma, beta = cache

N, D = X.shape

X_mu = X - mu
std_inv = 1. / np.sqrt(var + 1e-8)

dX_norm = dout * gamma
dvar = np.sum(dX_norm * X_mu, axis=0) * -.5 * std_inv**3
dmu = np.sum(dX_norm * -std_inv, axis=0) + dvar * np.mean(-2. * X_mu, axis=0)

dX = (dX_norm * std_inv) + (dvar * 2 * X_mu / N) + (dmu / N)
dgamma = np.sum(dout * X_norm, axis=0)
dbeta = np.sum(dout, axis=0)

return dX, dgamma, dbeta


### Convolution¶

Be the first to contribute!

### Dropout¶

Be the first to contribute!

### Linear¶

Be the first to contribute!

### LSTM¶

Be the first to contribute!

### Pooling¶

Max and average pooling layers.

Be the first to contribute!

### RNN¶

Be the first to contribute!

References

## Loss Functions¶

### Cross-Entropy¶

Cross-entropy loss, or log loss, measures the performance of a classification model whose output is a probability value between 0 and 1. Cross-entropy loss increases as the predicted probability diverges from the actual label. So predicting a probability of .012 when the actual observation label is 1 would be bad and result in a high loss value. A perfect model would have a log loss of 0. The graph above shows the range of possible loss values given a true observation (isDog = 1). As the predicted probability approaches 1, log loss slowly decreases. As the predicted probability decreases, however, the log loss increases rapidly. Log loss penalizes both types of errors, but especially those predications that are confident and wrong!

Cross-entropy and log loss are slightly different depending on context, but in machine learning when calculating error rates between 0 and 1 they resolve to the same thing.

Code

def CrossEntropy(yHat, y):
if yHat == 1:
return -log(y)
else:
return -log(1 - y)


Math

In binary classification, where the number of classes $$M$$ equals 2, cross-entropy can be calculated as:

$-{(y\log(p) + (1 - y)\log(1 - p))}$

If $$M > 2$$ (i.e. multiclass classification), we calculate a separate loss for each class label per observation and sum the result.

$-\sum_{c=1}^My_{o,c}\log(p_{o,c})$

Примечание

• M - number of classes (dog, cat, fish)
• log - the natural log
• y - binary indicator (0 or 1) if class label $$c$$ is the correct classification for observation $$o$$
• p - predicted probability observation $$o$$ is of class $$c$$

### Hinge¶

Used for classification.

Code

def Hinge(yHat, y):
return np.max(0, 1 - yHat * y)


### Huber¶

Typically used for regression. It’s less sensitive to outliers than the MSE.

Code

def Huber(yHat, y):
pass


### Kullback-Leibler¶

Code

def KLDivergence(yHat, y):
pass


### MAE (L1)¶

Mean Absolute Error, or L1 loss. Excellent overview below  and .

Code

def L1(yHat, y):
return np.sum(np.absolute(yHat - y))


### MSE (L2)¶

Mean Squared Error, or L2 loss. Excellent overview below  and .

def MSE(yHat, y):
return np.sum((yHat - y)**2) / y.size

def MSE_prime(yHat, y):
return yHat - y


References

## Optimizers¶

Be the first to contribute!

Be the first to contribute!

Adaptive Moment Estimation (Adam) combines ideas from both RMSProp and Momentum. It computes adaptive learning rates for each parameter and works as follows.

• First, it computes the exponentially weighted average of past gradients ($$v_{dW}$$).
• Second, it computes the exponentially weighted average of the squares of past gradients ($$s_{dW}$$).
• Third, these averages have a bias towards zero and to counteract this a bias correction is applied ($$v_{dW}^{corrected}$$, $$s_{dW}^{corrected}$$).
• Lastly, the parameters are updated using the information from the calculated averages.
$\begin{split}v_{dW} = \beta_1 v_{dW} + (1 - \beta_1) \frac{\partial \mathcal{J} }{ \partial W } \\ s_{dW} = \beta_2 s_{dW} + (1 - \beta_2) (\frac{\partial \mathcal{J} }{\partial W })^2 \\ v^{corrected}_{dW} = \frac{v_{dW}}{1 - (\beta_1)^t} \\ s^{corrected}_{dW} = \frac{s_{dW}}{1 - (\beta_1)^t} \\ W = W - \alpha \frac{v^{corrected}_{dW}}{\sqrt{s^{corrected}_{dW}} + \varepsilon}\end{split}$

Примечание

• $$v_{dW}$$ - the exponentially weighted average of past gradients
• $$s_{dW}$$ - the exponentially weighted average of past squares of gradients
• $$\beta_1$$ - hyperparameter to be tuned
• $$\beta_2$$ - hyperparameter to be tuned
• $$\frac{\partial \mathcal{J} }{ \partial W }$$ - cost gradient with respect to current layer
• $$W$$ - the weight matrix (parameter to be updated)
• $$\alpha$$ - the learning rate
• $$\epsilon$$ - very small value to avoid dividing by zero

Be the first to contribute!

### BFGS¶

Be the first to contribute!

### Momentum¶

Used in conjunction Stochastic Gradient Descent (sgd) or Mini-Batch Gradient Descent, Momentum takes into account past gradients to smooth out the update. This is seen in variable $$v$$ which is an exponentially weighted average of the gradient on previous steps. This results in minimizing oscillations and faster convergence.

$\begin{split}v_{dW} = \beta v_{dW} + (1 - \beta) \frac{\partial \mathcal{J} }{ \partial W } \\ W = W - \alpha v_{dW}\end{split}$

Примечание

• $$v$$ - the exponentially weighted average of past gradients
• $$\frac{\partial \mathcal{J} }{ \partial W }$$ - cost gradient with respect to current layer weight tensor
• $$W$$ - weight tensor
• $$\beta$$ - hyperparameter to be tuned
• $$\alpha$$ - the learning rate

### Nesterov Momentum¶

Be the first to contribute!

### Newton’s Method¶

Be the first to contribute!

### RMSProp¶

Another adaptive learning rate optimization algorithm, Root Mean Square Prop (RMSProp) works by keeping an exponentially weighted average of the squares of past gradients. RMSProp then divides the learning rate by this average to speed up convergence.

$\begin{split}s_{dW} = \beta s_{dW} + (1 - \beta) (\frac{\partial \mathcal{J} }{\partial W })^2 \\ W = W - \alpha \frac{\frac{\partial \mathcal{J} }{\partial W }}{\sqrt{s^{corrected}_{dW}} + \varepsilon}\end{split}$

Примечание

• $$s$$ - the exponentially weighted average of past squares of gradients
• $$\frac{\partial \mathcal{J} }{\partial W }$$ - cost gradient with respect to current layer weight tensor
• $$W$$ - weight tensor
• $$\beta$$ - hyperparameter to be tuned
• $$\alpha$$ - the learning rate
• $$\epsilon$$ - very small value to avoid dividing by zero

### SGD¶

def SGD(data, batch_size, lr):
N = len(data)
np.random.shuffle(data)
mini_batches = np.array([data[i:i+batch_size]
for i in range(0, N, batch_size)])
for X,y in mini_batches:
backprop(X, y, lr)


References

## Regularization¶

Techniques for combating overfitting and improving training.

### Data Augmentation¶

Be the first to contribute!

### Dropout¶

Be the first to contribute!

### Early Stopping¶

Be the first to contribute!

### Ensembling¶

Be the first to contribute!

### Injecting Noise¶

Be the first to contribute!

### L1 Regularization¶

Be the first to contribute!

### L2 Regularization¶

Be the first to contribute!

References

## Architectures¶

### Autoencoder¶

TODO: Description of Autoencoder use case and basic architecture. Figure from . Model

An example implementation in PyTorch.

class Autoencoder(nn.Module):
def __init__(self, in_shape):
super().__init__()
c,h,w = in_shape
self.encoder = nn.Sequential(
nn.Linear(c*h*w, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 12),
nn.ReLU()
)
self.decoder = nn.Sequential(
nn.Linear(12, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, c*h*w),
nn.Sigmoid()
)

def forward(self, x):
bs,c,h,w = x.size()
x = x.view(bs, -1)
x = self.encoder(x)
x = self.decoder(x)
x = x.view(bs, c, h, w)
return x


Training

def train(net, loader, loss_func, optimizer):
net.train()
inputs = Variable(inputs)

output = net(inputs)
loss = loss_func(output, inputs)

loss.backward()
optimizer.step()


### CNN¶

TODO: Description of CNN use case and basic architecture. Figure from . Model

An example implementation in PyTorch.

Training

### GAN¶

TODO: Description of GAN use case and basic architecture. Figure from . Model

TODO: An example implementation in PyTorch.

Training

TODO

### MLP¶

A Multi Layer Perceptron (MLP) is a neural network with only fully connected layers. Figure from . Model

An example implementation in Numpy or Pytorch?

TODO

Training

TODO

TODO

### RNN¶

Description of RNN use case and basic architecture. Model

class RNN(nn.Module):
def __init__(self, n_classes):
super().__init__()
self.hid_fc = nn.Linear(185, 128)
self.out_fc = nn.Linear(185, n_classes)
self.softmax = nn.LogSoftmax()

def forward(self, inputs, hidden):
inputs = inputs.view(1,-1)
combined = torch.cat([inputs, hidden], dim=1)
hid_out = self.hid_fc(combined)
out = self.out_fc(combined)
out = self.softmax(out)
return out, hid_out


Training

In this example, our input is a list of last names, where each name is a variable length array of one-hot encoded characters. Our target is is a list of indices representing the class (language) of the name.

1. For each input name..
2. Initialize the hidden vector
3. Loop through the characters and predict the class
4. Pass the final character’s prediction to the loss function
5. Backprop and update the weights
def train(model, inputs, targets):
for i in range(len(inputs)):
target = Variable(targets[i])
name = inputs[i]
hidden = Variable(torch.zeros(1,128))

for char in name:
input_ = Variable(torch.FloatTensor(char))
pred, hidden = model(input_, hidden)

loss = criterion(pred, target)
loss.backward()

for p in model.parameters():


### VAE¶

Autoencoders can encode an input image to a latent vector and decode it, but they can’t generate novel images. Variational Autoencoders (VAE) solve this problem by adding a constraint: the latent vector representation should model a unit gaussian distribution. The Encoder returns the mean and variance of the learned gaussian. To generate a new image, we pass a new mean and variance to the Decoder. In other words, we «sample a latent vector» from the gaussian and pass it to the Decoder. It also improves network generalization and avoids memorization. Figure from . Loss Function

The VAE loss function combines reconstruction loss (e.g. Cross Entropy, MSE) with KL divergence.

def vae_loss(output, input, mean, logvar, loss_func):
recon_loss = loss_func(output, input)
kl_loss = torch.mean(0.5 * torch.sum(
torch.exp(logvar) + mean**2 - 1. - logvar, 1))
return recon_loss + kl_loss


Model

An example implementation in PyTorch of a Convolutional Variational Autoencoder.

class VAE(nn.Module):
def __init__(self, in_shape, n_latent):
super().__init__()
self.in_shape = in_shape
self.n_latent = n_latent
c,h,w = in_shape
self.z_dim = h//2**2 # receptive field downsampled 2 times
self.encoder = nn.Sequential(
nn.BatchNorm2d(c),
nn.Conv2d(c, 32, kernel_size=4, stride=2, padding=1),  # 32, 16, 16
nn.BatchNorm2d(32),
nn.LeakyReLU(),
nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),  # 32, 8, 8
nn.BatchNorm2d(64),
nn.LeakyReLU(),
)
self.z_mean = nn.Linear(64 * self.z_dim**2, n_latent)
self.z_var = nn.Linear(64 * self.z_dim**2, n_latent)
self.z_develop = nn.Linear(n_latent, 64 * self.z_dim**2)
self.decoder = nn.Sequential(
nn.BatchNorm2d(32),
nn.ReLU(),
CenterCrop(h,w),
nn.Sigmoid()
)

def sample_z(self, mean, logvar):
stddev = torch.exp(0.5 * logvar)
noise = Variable(torch.randn(stddev.size()))
return (noise * stddev) + mean

def encode(self, x):
x = self.encoder(x)
x = x.view(x.size(0), -1)
mean = self.z_mean(x)
var = self.z_var(x)
return mean, var

def decode(self, z):
out = self.z_develop(z)
out = out.view(z.size(0), 64, self.z_dim, self.z_dim)
out = self.decoder(out)
return out

def forward(self, x):
mean, logvar = self.encode(x)
z = self.sample_z(mean, logvar)
out = self.decode(z)
return out, mean, logvar


Training

def train(model, loader, loss_func, optimizer):
model.train()
inputs = Variable(inputs)

output, mean, logvar = model(inputs)
loss = vae_loss(output, inputs, mean, logvar, loss_func)

loss.backward()
optimizer.step()


References

## Classification Algorithms¶

Many of these overlap with other algorithm categories…

Overlaps..

### Boosting¶

Be the first to contribute!

### Decision Trees¶

Be the first to contribute!

### K-Nearest Neighbor¶

Be the first to contribute!

### Logistic Regression¶

Be the first to contribute!

### Random Forests¶

Be the first to contribute!

### Support Vector Machines¶

Be the first to contribute!

References

  Example Reference

## Clustering Algorithms¶

### Centroid¶

Be the first to contribute!

### Density¶

Be the first to contribute!

### Distribution¶

Be the first to contribute!

### Hierarchical¶

Be the first to contribute!

### K-Means¶

Be the first to contribute!

### Mean shift¶

Be the first to contribute!

References

## Regression Algorithms¶

### Lasso¶

Be the first to contribute!

### Linear¶

Be the first to contribute!

### Ordinary Least Squares¶

Be the first to contribute!

### Polynomial¶

Be the first to contribute!

### Ridge¶

Be the first to contribute!

### Splines¶

Be the first to contribute!

### Stepwise¶

Be the first to contribute!

References

## Reinforcement Learning¶

Be the first to contribute!

References

  Example Reference

## Libraries¶

Machine learning libraries and frameworks forked from josephmisti’s awesome machine learning.

### APL¶

General-Purpose Machine Learning

• naive-apl - Naive Bayesian Classifier implementation in APL

### C¶

General-Purpose Machine Learning

• Darknet - Darknet is an open source neural network framework written in C and CUDA. It is fast, easy to install, and supports CPU and GPU computation.
• Recommender - A C library for product recommendations/suggestions using collaborative filtering (CF).
• Hybrid Recommender System - A hybrid recomender system based upon scikit-learn algorithms.

Computer Vision

• CCV - C-based/Cached/Core Computer Vision Library, A Modern Computer Vision Library
• VLFeat - VLFeat is an open and portable library of computer vision algorithms, which has Matlab toolbox

Speech Recognition

• HTK -The Hidden Markov Model Toolkit. HTK is a portable toolkit for building and manipulating hidden Markov models.

### C++¶

Computer Vision

• DLib - DLib has C++ and Python interfaces for face detection and training general object detectors.
• EBLearn - Eblearn is an object-oriented C++ library that implements various machine learning models
• OpenCV - OpenCV has C++, C, Python, Java and MATLAB interfaces and supports Windows, Linux, Android and Mac OS.
• VIGRA - VIGRA is a generic cross-platform C++ computer vision and machine learning library for volumes of arbitrary dimensionality with Python bindings.

General-Purpose Machine Learning

• BanditLib - A simple Multi-armed Bandit library.
• Caffe - A deep learning framework developed with cleanliness, readability, and speed in mind. [DEEP LEARNING]
• CNTK by Microsoft Research, is a unified deep-learning toolkit that describes neural networks as a series of computational steps via a directed graph.
• CUDA - This is a fast C++/CUDA implementation of convolutional [DEEP LEARNING]
• CXXNET - Yet another deep learning framework with less than 1000 lines core code [DEEP LEARNING]
• DeepDetect - A machine learning API and server written in C++11. It makes state of the art machine learning easy to work with and integrate into existing applications.
• Disrtibuted Machine learning Tool Kit (DMTK) Word Embedding.
• DLib - A suite of ML tools designed to be easy to imbed in other applications
• DSSTNE - A software library created by Amazon for training and deploying deep neural networks using GPUs which emphasizes speed and scale over experimental flexibility.
• DyNet - A dynamic neural network library working well with networks that have dynamic structures that change for every training instance. Written in C++ with bindings in Python.
• encog-cpp
• Fido - A highly-modular C++ machine learning library for embedded electronics and robotics.
• igraph - General purpose graph library
• Intel(R) DAAL - A high performance software library developed by Intel and optimized for Intel’s architectures. Library provides algorithmic building blocks for all stages of data analytics and allows to process data in batch, online and distributed modes.
• LightGBM framework based on decision tree algorithms, used for ranking, classification and many other machine learning tasks.
• MLDB - The Machine Learning Database is a database designed for machine learning. Send it commands over a RESTful API to store data, explore it using SQL, then train machine learning models and expose them as APIs.
• mlpack - A scalable C++ machine learning library
• ROOT - A modular scientific software framework. It provides all the functionalities needed to deal with big data processing, statistical analysis, visualization and storage.
• shark - A fast, modular, feature-rich open-source C++ machine learning library.
• Shogun - The Shogun Machine Learning Toolbox
• sofia-ml - Suite of fast incremental algorithms.
• Stan - A probabilistic programming language implementing full Bayesian statistical inference with Hamiltonian Monte Carlo sampling
• Timbl - A software package/C++ library implementing several memory-based learning algorithms, among which IB1-IG, an implementation of k-nearest neighbor classification, and IGTree, a decision-tree approximation of IB1-IG. Commonly used for NLP.
• Vowpal Wabbit (VW) - A fast out-of-core learning system.
• Warp-CTC, on both CPU and GPU.
• XGBoost - A parallelized optimized general purpose gradient boosting library.

Natural Language Processing

Speech Recognition

• Kaldi - Kaldi is a toolkit for speech recognition written in C++ and licensed under the Apache License v2.0. Kaldi is intended for use by speech recognition researchers.

Sequence Analysis

• ToPS - This is an objected-oriented framework that facilitates the integration of probabilistic models for sequences over a user defined alphabet.

Gesture Detection

• grt - The Gesture Recognition Toolkit. GRT is a cross-platform, open-source, C++ machine learning library designed for real-time gesture recognition.

### Common Lisp¶

General-Purpose Machine Learning

• mgl, Gaussian Processes
• mgl-gpr - Evolutionary algorithms
• cl-libsvm - Wrapper for the libsvm support vector machine library

### Clojure¶

Natural Language Processing

• Clojure-openNLP - Natural Language Processing in Clojure (opennlp)
• Infections-clj - Rails-like inflection library for Clojure and ClojureScript

General-Purpose Machine Learning

• Touchstone - Clojure A/B testing library
• Clojush - The Push programming language and the PushGP genetic programming system implemented in Clojure
• Infer - Inference and machine learning in clojure
• Clj-ML - A machine learning library for Clojure built on top of Weka and friends
• DL4CLJ - Clojure wrapper for Deeplearning4j
• Encog
• Fungp - A genetic programming library for Clojure
• Statistiker - Basic Machine Learning algorithms in Clojure.
• clortex - General Machine Learning library using Numenta’s Cortical Learning Algorithm
• comportex - Functionally composable Machine Learning library using Numenta’s Cortical Learning Algorithm
• cortex - Neural networks, regression and feature learning in Clojure.
• lambda-ml - Simple, concise implementations of machine learning techniques and utilities in Clojure.

Data Analysis / Data Visualization

• Incanter - Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
• PigPen - Map-Reduce for Clojure.
• Envision - Clojure Data Visualisation library, based on Statistiker and D3

### Elixir¶

General-Purpose Machine Learning

• Simple Bayes - A Simple Bayes / Naive Bayes implementation in Elixir.

Natural Language Processing

• Stemmer stemming implementation in Elixir.

### Erlang¶

General-Purpose Machine Learning

• Disco - Map Reduce in Erlang

### Go¶

Natural Language Processing

• go-porterstemmer - A native Go clean room implementation of the Porter Stemming algorithm.
• paicehusk - Golang implementation of the Paice/Husk Stemming Algorithm.
• snowball - Snowball Stemmer for Go.
• go-ngram - In-memory n-gram index with compression.

General-Purpose Machine Learning

• gago - Multi-population, flexible, parallel genetic algorithm.
• Go Learn - Machine Learning for Go
• go-pr - Pattern recognition package in Go lang.
• go-ml - Linear / Logistic regression, Neural Networks, Collaborative Filtering and Gaussian Multivariate Distribution
• bayesian - Naive Bayesian Classification for Golang.
• go-galib - Genetic Algorithms library written in Go / golang
• Cloudforest - Ensembles of decision trees in go/golang.
• gobrain - Neural Networks written in go
• GoNN - GoNN is an implementation of Neural Network in Go Language, which includes BPNN, RBF, PCN
• MXNet - Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Go, Javascript and more.
• go-mxnet-predictor - Go binding for MXNet c_predict_api to do inference with pre-trained model

Data Analysis / Data Visualization

• go-graph - Graph library for Go/golang language.
• SVGo - The Go Language library for SVG generation
• RF - Random forests implementation in Go

General-Purpose Machine Learning

• HLearn - a suite of libraries for interpreting machine learning models according to their algebraic structure.
• hnn - Haskell Neural Network library.
• hopfield-networks - Hopfield Networks for unsupervised learning in Haskell.
• caffegraph - A DSL for deep neural networks
• LambdaNet - Configurable Neural Networks in Haskell

### Java¶

Natural Language Processing

• Cortical.io as quickly and intuitively as the brain.
• CoreNLP - Stanford CoreNLP provides a set of natural language analysis tools which can take raw English language text input and give the base forms of words
• Stanford Parser - A natural language parser is a program that works out the grammatical structure of sentences
• Stanford POS Tagger - A Part-Of-Speech Tagger (POS Tagger
• Stanford Name Entity Recognizer - Stanford NER is a Java implementation of a Named Entity Recognizer.
• Stanford Word Segmenter - Tokenization of raw text is a standard pre-processing step for many NLP tasks.
• Tregex, Tsurgeon and Semgrex.
• Stanford Phrasal: A Phrase-Based Translation System
• Stanford English Tokenizer - Stanford Phrasal is a state-of-the-art statistical phrase-based machine translation system, written in Java.
• Stanford Tokens Regex - A tokenizer divides text into a sequence of tokens, which roughly correspond to «words»
• Stanford Temporal Tagger - SUTime is a library for recognizing and normalizing time expressions.
• Stanford SPIED - Learning entities from unlabeled text starting with seed sets using patterns in an iterative fashion
• Stanford Topic Modeling Toolbox - Topic modeling tools to social scientists and others who wish to perform analysis on datasets
• Twitter Text Java - A Java implementation of Twitter’s text processing library
• MALLET - A Java-based package for statistical natural language processing, document classification, clustering, topic modeling, information extraction, and other machine learning applications to text.
• OpenNLP - a machine learning based toolkit for the processing of natural language text.
• LingPipe - A tool kit for processing text using computational linguistics.
• ClearTK components in Java and is built on top of Apache UIMA.
• Apache cTAKES is an open-source natural language processing system for information extraction from electronic medical record clinical free-text.
• ClearNLP - The ClearNLP project provides software and resources for natural language processing. The project started at the Center for Computational Language and EducAtion Research, and is currently developed by the Center for Language and Information Research at Emory University. This project is under the Apache 2 license.
• CogcompNLP developed in the University of Illinois“ Cognitive Computation Group, for example illinois-core-utilities which provides a set of NLP-friendly data structures and a number of NLP-related utilities that support writing NLP applications, running experiments, etc, illinois-edison a library for feature extraction from illinois-core-utilities data structures and many other packages.

General-Purpose Machine Learning

• aerosolve - A machine learning library by Airbnb designed from the ground up to be human friendly.
• Datumbox - Machine Learning framework for rapid development of Machine Learning and Statistical applications
• ELKI
• Encog - An advanced neural network and machine learning framework. Encog contains classes to create a wide variety of networks, as well as support classes to normalize and process data for these neural networks. Encog trains using multithreaded resilient propagation. Encog can also make use of a GPU to further speed processing time. A GUI based workbench is also provided to help model and train neural networks.
• H2O - ML engine that supports distributed learning on Hadoop, Spark or your laptop via APIs in R, Python, Scala, REST/JSON.
• htm.java - General Machine Learning library using Numenta’s Cortical Learning Algorithm
• java-deeplearning - Distributed Deep Learning Platform for Java, Clojure,Scala
• Mahout - Distributed machine learning
• Meka.
• MLlib in Apache Spark - Distributed machine learning library in Spark
• Hydrosphere Mist - a service for deployment Apache Spark MLLib machine learning models as realtime, batch or reactive web services.
• Neuroph - Neuroph is lightweight Java neural network framework
• ORYX - Lambda Architecture Framework using Apache Spark and Apache Kafka with a specialization for real-time large-scale machine learning.
• Samoa SAMOA is a framework that includes distributed machine learning for data streams with an interface to plug-in different stream processing platforms.
• RankLib - RankLib is a library of learning to rank algorithms
• rapaio - statistics, data mining and machine learning toolbox in Java
• RapidMiner - RapidMiner integration into Java code
• Stanford Classifier - A classifier is a machine learning tool that will take data items and place them into one of k classes.
• SmileMiner - Statistical Machine Intelligence & Learning Engine
• SystemML language.
• WalnutiQ - object oriented model of the human brain
• Weka - Weka is a collection of machine learning algorithms for data mining tasks
• LBJava - Learning Based Java is a modeling language for the rapid development of software systems, offers a convenient, declarative syntax for classifier and constraint definition directly in terms of the objects in the programmer’s application.

Speech Recognition

• CMU Sphinx - Open Source Toolkit For Speech Recognition purely based on Java speech recognition library.

Data Analysis / Data Visualization

• Flink - Open source platform for distributed stream and batch data processing.
• Spark - Spark is a fast and general engine for large-scale data processing.
• Storm - Storm is a distributed realtime computation system.
• Impala - Real-time Query for Hadoop
• DataMelt - Mathematics software for numeric computation, statistics, symbolic calculations, data analysis and data visualization.
• Dr. Michael Thomas Flanagan’s Java Scientific Library

Deep Learning

• Deeplearning4j - Scalable deep learning for industry with parallel GPUs

### Javascript¶

Natural Language Processing

• NLP.js - NLP utilities in javascript and coffeescript
• natural - General natural language facilities for node
• Knwl.js - A Natural Language Processor in JS
• Retext - Extensible system for analyzing and manipulating natural language
• TextProcessing - Sentiment analysis, stemming and lemmatization, part-of-speech tagging and chunking, phrase extraction and named entity recognition.
• NLP Compromise - Natural Language processing in the browser

Data Analysis / Data Visualization

• D3.js
• High Charts
• NVD3.js
• dc.js
• chartjs
• dimple
• amCharts
• D3xter - Straight forward plotting built on D3
• statkit - Statistics kit for JavaScript
• datakit - A lightweight framework for data analysis in JavaScript
• science.js - Scientific and statistical computing in JavaScript.
• Z3d - Easily make interactive 3d plots built on Three.js
• Sigma.js - JavaScript library dedicated to graph drawing.
• C3.js- customizable library based on D3.js for easy chart drawing.
• Datamaps- Customizable SVG map/geo visualizations using D3.js.
• ZingChart- library written on Vanilla JS for big data visualization.
• cheminfo - Platform for data visualization and analysis, using the visualizer project.

General-Purpose Machine Learning

• Convnet.js - ConvNetJS is a Javascript library for training Deep Learning models[DEEP LEARNING]
• Clusterfck - Agglomerative hierarchical clustering implemented in Javascript for Node.js and the browser
• Clustering.js - Clustering algorithms implemented in Javascript for Node.js and the browser
• Decision Trees - NodeJS Implementation of Decision Tree using ID3 Algorithm
• DN2A - Digital Neural Networks Architecture
• figue - K-means, fuzzy c-means and agglomerative clustering
• Node-fann bindings for Node.js
• Kmeans.js - Simple Javascript implementation of the k-means algorithm, for node.js and the browser
• LDA.js - LDA topic modeling for node.js
• Learning.js - Javascript implementation of logistic regression/c4.5 decision tree
• Machine Learning - Machine learning library for Node.js
• machineJS - Automated machine learning, data formatting, ensembling, and hyperparameter optimization for competitions and exploration- just give it a .csv file!
• mil-tokyo - List of several machine learning libraries
• Node-SVM - Support Vector Machine for nodejs
• Brain - Neural networks in JavaScript [Deprecated]
• Bayesian-Bandit - Bayesian bandit implementation for Node and the browser.
• Synaptic - Architecture-free neural network library for node.js and the browser
• kNear - JavaScript implementation of the k nearest neighbors algorithm for supervised learning
• NeuralN - C++ Neural Network library for Node.js. It has advantage on large dataset and multi-threaded training.
• kalman - Kalman filter for Javascript.
• shaman - node.js library with support for both simple and multiple linear regression.
• ml.js - Machine learning and numerical analysis tools for Node.js and the Browser!
• Pavlov.js - Reinforcement learning using Markov Decision Processes
• MXNet - Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Go, Javascript and more.

Misc

• sylvester - Vector and Matrix math for JavaScript.
• simple-statistics as well as in node.js.
• regression-js - A javascript library containing a collection of least squares fitting methods for finding a trend in a set of data.
• Lyric - Linear Regression library.
• GreatCircle - Library for calculating great circle distance.

### Julia¶

General-Purpose Machine Learning

• MachineLearning - Julia Machine Learning library
• MLBase - A set of functions to support the development of machine learning algorithms
• PGM - A Julia framework for probabilistic graphical models.
• DA - Julia package for Regularized Discriminant Analysis
• Regression
• Local Regression - Local regression, so smooooth!
• Naive Bayes - Simple Naive Bayes implementation in Julia
• Mixed Models mixed-effects models
• Simple MCMC - basic mcmc sampler implemented in Julia
• Distance - Julia module for Distance evaluation
• Decision Tree - Decision Tree Classifier and Regressor
• Neural - A neural network in Julia
• MCMC - MCMC tools for Julia
• Mamba for Bayesian analysis in Julia
• GLM - Generalized linear models in Julia
• Online Learning
• GLMNet - Julia wrapper for fitting Lasso/ElasticNet GLM models using glmnet
• Clustering - Basic functions for clustering data: k-means, dp-means, etc.
• SVM - SVM’s for Julia
• Kernal Density - Kernel density estimators for julia
• Dimensionality Reduction - Methods for dimensionality reduction
• NMF - A Julia package for non-negative matrix factorization
• ANN - Julia artificial neural networks
• Mocha - Deep Learning framework for Julia inspired by Caffe
• XGBoost - eXtreme Gradient Boosting Package in Julia
• ManifoldLearning - A Julia package for manifold learning and nonlinear dimensionality reduction
• MXNet - Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Go, Javascript and more.
• Merlin - Flexible Deep Learning Framework in Julia
• ROCAnalysis - Receiver Operating Characteristics and functions for evaluation probabilistic binary classifiers
• GaussianMixtures - Large scale Gaussian Mixture Models
• ScikitLearn - Julia implementation of the scikit-learn API
• Knet - Koç University Deep Learning Framework

Natural Language Processing

Data Analysis / Data Visualization

• Graph Layout - Graph layout algorithms in pure Julia
• Data Frames Meta - Metaprogramming tools for DataFrames
• Julia Data - library for working with tabular data in Julia
• Hypothesis Tests - Hypothesis tests for Julia
• Gadfly - Crafty statistical graphics for Julia.
• Stats - Statistical tests for Julia
• RDataSets - Julia package for loading many of the data sets available in R
• DataFrames - library for working with tabular data in Julia
• Distributions - A Julia package for probability distributions and associated functions.
• Data Arrays - Data structures that allow missing values
• Time Series - Time series toolkit for Julia
• Sampling - Basic sampling algorithms for Julia

Misc Stuff / Presentations

### Lua¶

General-Purpose Machine Learning

• Torch7
• cephes - Cephes mathematical functions library, wrapped for Torch. Provides and wraps the 180+ special mathematical functions from the Cephes mathematical library, developed by Stephen L. Moshier. It is used, among many other places, at the heart of SciPy.
• autograd - Autograd automatically differentiates native Torch code. Inspired by the original Python version.
• graph - Graph package for Torch
• randomkit - Numpy’s randomkit, wrapped for Torch
• signal - A signal processing toolbox for Torch-7. FFT, DCT, Hilbert, cepstrums, stft
• nn - Neural Network package for Torch
• torchnet - framework for torch which provides a set of abstractions aiming at encouraging code re-use as well as encouraging modular programming
• nngraph - This package provides graphical computation for nn library in Torch7.
• nnx - A completely unstable and experimental package that extends Torch’s builtin nn library
• rnn - A Recurrent Neural Network library that extends Torch’s nn. RNNs, LSTMs, GRUs, BRNNs, BLSTMs, etc.
• dpnn - Many useful features that aren’t part of the main nn package.
• dp - A deep learning library designed for streamlining research and development using the Torch7 distribution. It emphasizes flexibility through the elegant use of object-oriented design patterns.
• unsup.
• manifold - A package to manipulate manifolds
• svm - Torch-SVM library
• lbfgs - FFI Wrapper for liblbfgs
• vowpalwabbit - An old vowpalwabbit interface to torch.
• OpenGM - OpenGM is a C++ library for graphical modeling, and inference. The Lua bindings provide a simple way of describing graphs, from Lua, and then optimizing them with OpenGM.
• sphagetti module for torch7 by @MichaelMathieu
• LuaSHKit - A lua wrapper around the Locality sensitive hashing library SHKit
• kernel smoothing - KNN, kernel-weighted average, local linear regression smoothers
• cutorch - Torch CUDA Implementation
• cunn - Torch CUDA Neural Network Implementation
• imgraph - An image/graph library for Torch. This package provides routines to construct graphs on images, segment them, build trees out of them, and convert them back to images.
• videograph - A video/graph library for Torch. This package provides routines to construct graphs on videos, segment them, build trees out of them, and convert them back to videos.
• saliency - code and tools around integral images. A library for finding interest points based on fast integral histograms.
• stitch - allows us to use hugin to stitch images and apply same stitching to a video sequence
• sfm - A bundle adjustment/structure from motion package
• fex - A package for feature extraction in Torch. Provides SIFT and dSIFT modules.
• OverFeat - A state-of-the-art generic dense feature extractor
• Numeric Lua
• Lunatic Python
• SciLua
• Lua - Numerical Algorithms
• Lunum

Demos and Scripts

• Core torch7 demos repository. * linear-regression, logistic-regression * face detector (training and detection as separate demos) * mst-based-segmenter * train-a-digit-classifier * train-autoencoder * optical flow demo * train-on-housenumbers * train-on-cifar * tracking with deep nets * kinect demo * filter-bank visualization * saliency-networks
• Training a Convnet for the Galaxy-Zoo Kaggle challenge(CUDA demo)
• Music Tagging - Music Tagging scripts for torch7
• torch-datasets - Scripts to load several popular datasets including: * BSR 500 * CIFAR-10 * COIL * Street View House Numbers * MNIST * NORB
• Atari2600 - Scripts to generate a dataset with static frames from the Arcade Learning Environment

### Matlab¶

Computer Vision

• Contourlets - MATLAB source code that implements the contourlet transform and its utility functions.
• Shearlets - MATLAB code for shearlet transform
• Curvelets - The Curvelet transform is a higher dimensional generalization of the Wavelet transform designed to represent images at different scales and different angles.
• Bandlets - MATLAB code for bandlet transform
• mexopencv - Collection and a development kit of MATLAB mex functions for OpenCV library

Natural Language Processing

• NLP - An NLP library for Matlab

General-Purpose Machine Learning

Data Analysis / Data Visualization

• matlab_gbl - MatlabBGL is a Matlab package for working with graphs.
• gamic - Efficient pure-Matlab implementations of graph algorithms to complement MatlabBGL’s mex functions.

### .NET¶

Computer Vision

• OpenCVDotNet - A wrapper for the OpenCV project to be used with .NET applications.
• Emgu CV - Cross platform wrapper of OpenCV which can be compiled in Mono to e run on Windows, Linus, Mac OS X, iOS, and Android.
• AForge.NET - Open source C# framework for developers and researchers in the fields of Computer Vision and Artificial Intelligence. Development has now shifted to GitHub.
• Accord.NET - Together with AForge.NET, this library can provide image processing and computer vision algorithms to Windows, Windows RT and Windows Phone. Some components are also available for Java and Android.

Natural Language Processing

• Stanford.NLP for .NET - A full port of Stanford NLP packages to .NET and also available precompiled as a NuGet package.

General-Purpose Machine Learning

• Accord-Framework -The Accord.NET Framework is a complete framework for building machine learning, computer vision, computer audition, signal processing and statistical applications.
• Accord.MachineLearning - Support Vector Machines, Decision Trees, Naive Bayesian models, K-means, Gaussian Mixture models and general algorithms such as Ransac, Cross-validation and Grid-Search for machine-learning applications. This package is part of the Accord.NET Framework.
• DiffSharp for machine learning and optimization applications. Operations can be nested to any level, meaning that you can compute exact higher-order derivatives and differentiate functions that are internally making use of differentiation, for applications such as hyperparameter optimization.
• Vulpes - Deep belief and deep learning implementation written in F# and leverages CUDA GPU execution with Alea.cuBase.
• Encog - An advanced neural network and machine learning framework. Encog contains classes to create a wide variety of networks, as well as support classes to normalize and process data for these neural networks. Encog trains using multithreaded resilient propagation. Encog can also make use of a GPU to further speed processing time. A GUI based workbench is also provided to help model and train neural networks.
• Neural Network Designer - DBMS management system and designer for neural networks. The designer application is developed using WPF, and is a user interface which allows you to design your neural network, query the network, create and configure chat bots that are capable of asking questions and learning from your feed back. The chat bots can even scrape the internet for information to return in their output as well as to use for learning.
• Infer.NET - Infer.NET is a framework for running Bayesian inference in graphical models. One can use Infer.NET to solve many different kinds of machine learning problems, from standard problems like classification, recommendation or clustering through to customised solutions to domain-specific problems. Infer.NET has been used in a wide variety of domains including information retrieval, bioinformatics, epidemiology, vision, and many others.

Data Analysis / Data Visualization

• numl - numl is a machine learning library intended to ease the use of using standard modeling techniques for both prediction and clustering.
• Math.NET Numerics - Numerical foundation of the Math.NET project, aiming to provide methods and algorithms for numerical computations in science, engineering and every day use. Supports .Net 4.0, .Net 3.5 and Mono on Windows, Linux and Mac; Silverlight 5, WindowsPhone/SL 8, WindowsPhone 8.1 and Windows 8 with PCL Portable Profiles 47 and 344; Android/iOS with Xamarin.
• Sho to enable fast and flexible prototyping. The environment includes powerful and efficient libraries for linear algebra as well as data visualization that can be used from any .NET language, as well as a feature-rich interactive shell for rapid development.

### Objective C¶

General-Purpose Machine Learning

• YCML.
• MLPNeuralNet - Fast multilayer perceptron neural network library for iOS and Mac OS X. MLPNeuralNet predicts new examples by trained neural network. It is built on top of the Apple’s Accelerate Framework, using vectorized operations and hardware acceleration if available.
• MAChineLearning - An Objective-C multilayer perceptron library, with full support for training through backpropagation. Implemented using vDSP and vecLib, it’s 20 times faster than its Java equivalent. Includes sample code for use from Swift.
• BPN-NeuralNetwork. This network can be used in products recommendation, user behavior analysis, data mining and data analysis.
• Multi-Perceptron-NeuralNetwork and designed unlimited-hidden-layers.
• KRHebbian-Algorithm in neural network of Machine Learning.
• KRKmeans-Algorithm - It implemented K-Means the clustering and classification algorithm. It could be used in data mining and image compression.
• KRFuzzyCMeans-Algorithm the fuzzy clustering / classification algorithm on Machine Learning. It could be used in data mining and image compression.

### OCaml¶

General-Purpose Machine Learning

• Oml - A general statistics and machine learning library.
• GPR - Efficient Gaussian Process Regression in OCaml.
• Libra-Tk - Algorithms for learning and inference with discrete probabilistic models.
• TensorFlow - OCaml bindings for TensorFlow.

### PHP¶

Natural Language Processing

• jieba-php - Chinese Words Segmentation Utilities.

General-Purpose Machine Learning

• PHP-ML - Machine Learning library for PHP. Algorithms, Cross Validation, Neural Network, Preprocessing, Feature Extraction and much more in one library.
• PredictionBuilder - A library for machine learning that builds predictions using a linear regression.

### Python¶

Computer Vision

• Scikit-Image - A collection of algorithms for image processing in Python.
• SimpleCV - An open source computer vision framework that gives access to several high-powered computer vision libraries, such as OpenCV. Written on Python and runs on Mac, Windows, and Ubuntu Linux.
• Vigranumpy - Python bindings for the VIGRA C++ computer vision library.
• OpenFace - Free and open source face recognition with deep neural networks.
• PCV - Open source Python module for computer vision

Natural Language Processing

General-Purpose Machine Learning

• auto_ml - Automated machine learning for production and analytics. Lets you focus on the fun parts of ML, while outputting production-ready code, and detailed analytics of your dataset and results. Includes support for NLP, XGBoost, LightGBM, and soon, deep learning.
• machine learning](https://github.com/jeff1evesque/machine-learning) - automated build consisting of a [web-interface](https://github.com/jeff1evesque/machine-learning#web-interface), and set of [programmatic-interface, are stored into a NoSQL datastore.
• XGBoost Library
• Bayesian Methods for Hackers - Book/iPython notebooks on Probabilistic Programming in Python
• Featureforge A set of tools for creating and testing machine learning features, with a scikit-learn compatible API
• MLlib in Apache Spark - Distributed machine learning library in Spark
• Hydrosphere Mist - a service for deployment Apache Spark MLLib machine learning models as realtime, batch or reactive web services.
• scikit-learn - A Python module for machine learning built on top of SciPy.
• metric-learn - A Python module for metric learning.
• SimpleAI Python implementation of many of the artificial intelligence algorithms described on the book «Artificial Intelligence, a Modern Approach». It focuses on providing an easy to use, well documented and tested library.
• astroML - Machine Learning and Data Mining for Astronomy.
• graphlab-create implemented on top of a disk-backed DataFrame.
• BigML - A library that contacts external servers.
• pattern - Web mining module for Python.
• NuPIC - Numenta Platform for Intelligent Computing.
• Pylearn2](https://github.com/lisa-lab/pylearn2) - A Machine Learning library based on [Theano.
• keras](https://github.com/fchollet/keras) - Modular neural network library based on [Theano.
• Lasagne - Lightweight library to build and train neural networks in Theano.
• hebel - GPU-Accelerated Deep Learning Library in Python.
• Chainer - Flexible neural network framework
• prohpet - Fast and automated time series forecasting framework by Facebook.
• gensim - Topic Modelling for Humans.
• topik - Topic modelling toolkit
• PyBrain - Another Python Machine Learning Library.
• Brainstorm - Fast, flexible and fun neural networks. This is the successor of PyBrain.
• Crab - A ﬂexible, fast recommender engine.
• python-recsys - A Python library for implementing a Recommender System.
• thinking bayes - Book on Bayesian Analysis
• Image-to-Image Translation with Conditional Adversarial Networks](https://github.com/williamFalcon/pix2pix-keras) - Implementation of image to image (pix2pix) translation from the paper by [isola et al.[DEEP LEARNING]
• Restricted Boltzmann Machines -Restricted Boltzmann Machines in Python. [DEEP LEARNING]
• Bolt - Bolt Online Learning Toolbox
• CoverTree - Python implementation of cover trees, near-drop-in replacement for scipy.spatial.kdtree
• nilearn - Machine learning for NeuroImaging in Python
• imbalanced-learn - Python module to perform under sampling and over sampling with various techniques.
• Shogun - The Shogun Machine Learning Toolbox
• Pyevolve - Genetic algorithm framework.
• Caffe - A deep learning framework developed with cleanliness, readability, and speed in mind.
• breze - Theano based library for deep and recurrent neural networks
• pyhsmm, focusing on the Bayesian Nonparametric extensions, the HDP-HMM and HDP-HSMM, mostly with weak-limit approximations.
• mrjob - A library to let Python program run on Hadoop.
• SKLL - A wrapper around scikit-learn that makes it simpler to conduct experiments.
• neurolab - https://github.com/zueve/neurolab
• Spearmint - Spearmint is a package to perform Bayesian optimization according to the algorithms outlined in the paper: Practical Bayesian Optimization of Machine Learning Algorithms. Jasper Snoek, Hugo Larochelle and Ryan P. Adams. Advances in Neural Information Processing Systems, 2012.
• Pebl - Python Environment for Bayesian Learning
• Theano - Optimizing GPU-meta-programming code generating array oriented optimizing math compiler in Python
• TensorFlow - Open source software library for numerical computation using data flow graphs
• yahmm - Hidden Markov Models for Python, implemented in Cython for speed and efficiency.
• python-timbl - A Python extension module wrapping the full TiMBL C++ programming interface. Timbl is an elaborate k-Nearest Neighbours machine learning toolkit.
• deap - Evolutionary algorithm framework.
• pydeep - Deep Learning In Python
• mlxtend - A library consisting of useful tools for data science and machine learning tasks.
• neon](https://github.com/NervanaSystems/neon) - Nervana’s [high-performance Python-based Deep Learning framework [DEEP LEARNING]
• Optunity - A library dedicated to automated hyperparameter optimization with a simple, lightweight API to facilitate drop-in replacement of grid search.
• Neural Networks and Deep Learning - Code samples for my book «Neural Networks and Deep Learning» [DEEP LEARNING]
• Annoy - Approximate nearest neighbours implementation
• skflow - Simplified interface for TensorFlow, mimicking Scikit Learn.
• TPOT - Tool that automatically creates and optimizes machine learning pipelines using genetic programming. Consider it your personal data science assistant, automating a tedious part of machine learning.
• pgmpy A python library for working with Probabilistic Graphical Models.
• DIGITS is a web application for training deep learning models.
• Orange - Open source data visualization and data analysis for novices and experts.
• MXNet - Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Go, Javascript and more.
• milk - Machine learning toolkit focused on supervised classification.
• TFLearn - Deep learning library featuring a higher-level API for TensorFlow.
• REP - an IPython-based environment for conducting data-driven research in a consistent and reproducible way. REP is not trying to substitute scikit-learn, but extends it and provides better user experience.
• rgf_python Library.
• gym - OpenAI Gym is a toolkit for developing and comparing reinforcement learning algorithms.
• skbayes - Python package for Bayesian Machine Learning with scikit-learn API
• fuku-ml - Simple machine learning library, including Perceptron, Regression, Support Vector Machine, Decision Tree and more, it’s easy to use and easy to learn for beginners.

Data Analysis / Data Visualization

• SciPy - A Python-based ecosystem of open-source software for mathematics, science, and engineering.
• NumPy - A fundamental package for scientific computing with Python.
• Numba complier to LLVM aimed at scientific Python by the developers of Cython and NumPy.
• NetworkX - A high-productivity software for complex networks.
• igraph - binding to igraph library - General purpose graph library
• Pandas - A library providing high-performance, easy-to-use data structures and data analysis tools.
• Open Mining
• PyMC - Markov Chain Monte Carlo sampling toolkit.
• zipline - A Pythonic algorithmic trading library.
• PyDy - Short for Python Dynamics, used to assist with workflow in the modeling of dynamic motion based around NumPy, SciPy, IPython, and matplotlib.
• SymPy - A Python library for symbolic mathematics.
• statsmodels - Statistical modeling and econometrics in Python.
• astropy - A community Python library for Astronomy.
• matplotlib - A Python 2D plotting library.
• bokeh - Interactive Web Plotting for Python.
• plotly - Collaborative web plotting for Python and matplotlib.
• vincent - A Python to Vega translator.
• d3py](https://github.com/mikedewar/d3py) - A plotting library for Python, based on [D3.js.
• PyDexter - Simple plotting for Python. Wrapper for D3xterjs; easily render charts in-browser.
• ggplot - Same API as ggplot2 for R.
• ggfortify - Unified interface to ggplot2 popular R packages.
• Kartograph.py - Rendering beautiful SVG maps in Python.
• pygal - A Python SVG Charts Creator.
• PyQtGraph - A pure-python graphics and GUI library built on PyQt4 / PySide and NumPy.
• Petrel - Tools for writing, submitting, debugging, and monitoring Storm topologies in pure Python.
• Blaze - NumPy and Pandas interface to Big Data.
• emcee - The Python ensemble sampling toolkit for affine-invariant MCMC.
• windML - A Python Framework for Wind Energy Analysis and Prediction
• vispy - GPU-based high-performance interactive OpenGL 2D/3D data visualization library
• cerebro2 A web-based visualization and debugging platform for NuPIC.
• NuPIC Studio An all-in-one NuPIC Hierarchical Temporal Memory visualization and debugging super-tool!
• SparklingPandas
• Seaborn - A python visualization library based on matplotlib
• bqplot
• pastalog - Simple, realtime visualization of neural network training performance.
• caravel - A data exploration platform designed to be visual, intuitive, and interactive.
• Dora - Tools for exploratory data analysis in Python.
• Ruffus - Computation Pipeline library for python.
• SOMPY.
• somoclu Massively parallel self-organizing maps: accelerate training on multicore CPUs, GPUs, and clusters, has python API.
• HDBScan - implementation of the hdbscan algorithm in Python - used for clustering
• visualize_ML - A python package for data exploration and data analysis.
• scikit-plot - A visualization library for quick and easy generation of common plots in data analysis and machine learning.

Neural networks

• Neural networks - NeuralTalk is a Python+numpy project for learning Multimodal Recurrent Neural Networks that describe images with sentences.
• Neuron neural networks learned with Gradient descent or LeLevenberg–Marquardt algorithm.
• Data Driven Code - Very simple implementation of neural networks for dummies in python without using any libraries, with detailed comments.

### Ruby¶

Natural Language Processing

• Treat - Text REtrieval and Annotation Toolkit, definitely the most comprehensive toolkit I’ve encountered so far for Ruby
• Ruby Linguistics - Linguistics is a framework for building linguistic utilities for Ruby objects in any language. It includes a generic language-independent front end, a module for mapping language codes into language names, and a module which contains various English-language utilities.
• Stemmer - Expose libstemmer_c to Ruby
• Ruby Wordnet - This library is a Ruby interface to WordNet
• Raspel - raspell is an interface binding for ruby
• UEA Stemmer - Ruby port of UEALite Stemmer - a conservative stemmer for search and indexing
• Twitter-text-rb - A library that does auto linking and extraction of usernames, lists and hashtags in tweets

General-Purpose Machine Learning

Data Analysis / Data Visualization

• rsruby - Ruby - R bridge
• data-visualization-ruby - Source code and supporting content for my Ruby Manor presentation on Data Visualisation with Ruby
• ruby-plot - gnuplot wrapper for ruby, especially for plotting roc curves into svg files
• plot-rb - A plotting library in Ruby built on top of Vega and D3.
• scruffy - A beautiful graphing toolkit for Ruby
• SciRuby
• Glean - A data management tool for humans
• Bioruby
• Arel

Misc

### Rust¶

General-Purpose Machine Learning

### R¶

General-Purpose Machine Learning

• ahaz - ahaz: Regularization for semiparametric additive hazards regression
• arules - arules: Mining Association Rules and Frequent Itemsets
• biglasso - biglasso: Extending Lasso Model Fitting to Big Data in R
• bigrf - bigrf: Big Random Forests: Classification and Regression Forests for Large Data Sets
• bigRR <http://cran.r-project.org/web/packages/bigRR/index.html) - bigRR: Generalized Ridge Regression (with special advantage for p >> n cases>__
• bmrm - bmrm: Bundle Methods for Regularized Risk Minimization Package
• Boruta - Boruta: A wrapper algorithm for all-relevant feature selection
• bst - bst: Gradient Boosting
• C50 - C50: C5.0 Decision Trees and Rule-Based Models
• caret - Classification and Regression Training: Unified interface to ~150 ML algorithms in R.
• caretEnsemble - caretEnsemble: Framework for fitting multiple caret models as well as creating ensembles of such models.
• Clever Algorithms For Machine Learning
• CORElearn - CORElearn: Classification, regression, feature evaluation and ordinal evaluation
• CoxBoost - CoxBoost: Cox models by likelihood based boosting for a single survival endpoint or competing risks
• Cubist - Cubist: Rule- and Instance-Based Regression Modeling
• e1071, TU Wien
• earth - earth: Multivariate Adaptive Regression Spline Models
• elasticnet - elasticnet: Elastic-Net for Sparse Estimation and Sparse PCA
• ElemStatLearn - ElemStatLearn: Data sets, functions and examples from the book: «The Elements of Statistical Learning, Data Mining, Inference, and Prediction» by Trevor Hastie, Robert Tibshirani and Jerome Friedman Prediction» by Trevor Hastie, Robert Tibshirani and Jerome Friedman
• evtree - evtree: Evolutionary Learning of Globally Optimal Trees
• forecast - forecast: Timeseries forecasting using ARIMA, ETS, STLM, TBATS, and neural network models
• forecastHybrid - forecastHybrid: Automatic ensemble and cross validation of ARIMA, ETS, STLM, TBATS, and neural network models from the «forecast» package
• fpc - fpc: Flexible procedures for clustering
• frbs - frbs: Fuzzy Rule-based Systems for Classification and Regression Tasks
• GAMBoost - GAMBoost: Generalized linear and additive models by likelihood based boosting
• gamboostLSS - gamboostLSS: Boosting Methods for GAMLSS
• gbm - gbm: Generalized Boosted Regression Models
• glmnet - glmnet: Lasso and elastic-net regularized generalized linear models
• glmpath - glmpath: L1 Regularization Path for Generalized Linear Models and Cox Proportional Hazards Model
• GMMBoost - GMMBoost: Likelihood-based Boosting for Generalized mixed models
• grplasso - grplasso: Fitting user specified models with Group Lasso penalty
• grpreg - grpreg: Regularization paths for regression models with grouped covariates
• h2o - A framework for fast, parallel, and distributed machine learning algorithms at scale – Deeplearning, Random forests, GBM, KMeans, PCA, GLM
• hda - hda: Heteroscedastic Discriminant Analysis
• Introduction to Statistical Learning
• ipred - ipred: Improved Predictors
• kernlab - kernlab: Kernel-based Machine Learning Lab
• klaR - klaR: Classification and visualization
• lars - lars: Least Angle Regression, Lasso and Forward Stagewise
• lasso2 - lasso2: L1 constrained estimation aka ‘lasso’
• LiblineaR - LiblineaR: Linear Predictive Models Based On The Liblinear C/C++ Library
• LogicReg - LogicReg: Logic Regression
• Machine Learning For Hackers
• maptree - maptree: Mapping, pruning, and graphing tree models
• mboost - mboost: Model-Based Boosting
• medley - medley: Blending regression models, using a greedy stepwise approach
• mlr - mlr: Machine Learning in R
• mvpart - mvpart: Multivariate partitioning
• ncvreg - ncvreg: Regularization paths for SCAD- and MCP-penalized regression models
• nnet - nnet: Feed-forward Neural Networks and Multinomial Log-Linear Models
• oblique.tree - oblique.tree: Oblique Trees for Classification Data
• pamr - pamr: Pam: prediction analysis for microarrays
• party - party: A Laboratory for Recursive Partytioning
• partykit - partykit: A Toolkit for Recursive Partytioning
• penalized penalized estimation in GLMs and in the Cox model
• penalizedLDA - penalizedLDA: Penalized classification using Fisher’s linear discriminant
• penalizedSVM - penalizedSVM: Feature Selection SVM using penalty functions
• quantregForest - quantregForest: Quantile Regression Forests
• randomForest - randomForest: Breiman and Cutler’s random forests for classification and regression
• randomForestSRC
• rattle - rattle: Graphical user interface for data mining in R
• rda - rda: Shrunken Centroids Regularized Discriminant Analysis
• rdetools in Feature Spaces
• REEMtree Data
• relaxo - relaxo: Relaxed Lasso
• rgenoud - rgenoud: R version of GENetic Optimization Using Derivatives
• rgp - rgp: R genetic programming framework
• Rmalschains in R
• rminer in classification and regression
• ROCR - ROCR: Visualizing the performance of scoring classifiers
• RoughSets - RoughSets: Data Analysis Using Rough Set and Fuzzy Rough Set Theories
• rpart - rpart: Recursive Partitioning and Regression Trees
• RPMM - RPMM: Recursively Partitioned Mixture Model
• RSNNS
• RWeka - RWeka: R/Weka interface
• RXshrink - RXshrink: Maximum Likelihood Shrinkage via Generalized Ridge or Least Angle Regression
• sda - sda: Shrinkage Discriminant Analysis and CAT Score Variable Selection
• SDDA - SDDA: Stepwise Diagonal Discriminant Analysis
• SuperLearner](https://github.com/ecpolley/SuperLearner) and [subsemble - Multi-algorithm ensemble learning packages.
• svmpath - svmpath: svmpath: the SVM Path algorithm
• tgp - tgp: Bayesian treed Gaussian process models
• tree - tree: Classification and regression trees
• varSelRF - varSelRF: Variable selection using random forests
• XGBoost.R Library
• Optunity - A library dedicated to automated hyperparameter optimization with a simple, lightweight API to facilitate drop-in replacement of grid search. Optunity is written in Python but interfaces seamlessly to R.
• igraph - binding to igraph library - General purpose graph library
• MXNet - Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler; for Python, R, Julia, Go, Javascript and more.
• TDSP-Utilities.

Data Analysis / Data Visualization

• ggplot2 - A data visualization package based on the grammar of graphics.

### SAS¶

General-Purpose Machine Learning

• Enterprise Miner - Data mining and machine learning that creates deployable models using a GUI or code.
• Factory Miner - Automatically creates deployable machine learning models across numerous market or customer segments using a GUI.

Data Analysis / Data Visualization

• SAS/STAT - For conducting advanced statistical analysis.
• University Edition - FREE! Includes all SAS packages necessary for data analysis and visualization, and includes online SAS courses.

High Performance Machine Learning

Natural Language Processing

Demos and Scripts

• ML_Tables - Concise cheat sheets containing machine learning best practices.
• enlighten-apply - Example code and materials that illustrate applications of SAS machine learning techniques.
• enlighten-integration - Example code and materials that illustrate techniques for integrating SAS with other analytics technologies in Java, PMML, Python and R.
• enlighten-deep - Example code and materials that illustrate using neural networks with several hidden layers in SAS.
• dm-flow - Library of SAS Enterprise Miner process flow diagrams to help you learn by example about specific data mining topics.

### Scala¶

Natural Language Processing

• ScalaNLP - ScalaNLP is a suite of machine learning and numerical computing libraries.
• Breeze - Breeze is a numerical processing library for Scala.
• Chalk - Chalk is a natural language processing library.
• FACTORIE - FACTORIE is a toolkit for deployable probabilistic modeling, implemented as a software library in Scala. It provides its users with a succinct language for creating relational factor graphs, estimating parameters and performing inference.

Data Analysis / Data Visualization

• MLlib in Apache Spark - Distributed machine learning library in Spark
• Hydrosphere Mist - a service for deployment Apache Spark MLLib machine learning models as realtime, batch or reactive web services.
• Scalding - A Scala API for Cascading
• Summing Bird - Streaming MapReduce with Scalding and Storm
• Algebird - Abstract Algebra for Scala
• xerial - Data management utilities for Scala
• simmer - Reduce your data. A unix filter for algebird-powered aggregation.
• PredictionIO - PredictionIO, a machine learning server for software developers and data engineers.
• BIDMat - CPU and GPU-accelerated matrix library intended to support large-scale exploratory data analysis.
• Wolfe Declarative Machine Learning
• Flink - Open source platform for distributed stream and batch data processing.
• Spark Notebook - Interactive and Reactive Data Science using Scala and Spark.

General-Purpose Machine Learning

• Conjecture - Scalable Machine Learning in Scalding
• brushfire - Distributed decision tree ensemble learning in Scala
• ganitha - scalding powered machine learning
• adam - A genomics processing engine and specialized file format built using Apache Avro, Apache Spark and Parquet. Apache 2 licensed.
• bioscala - Bioinformatics for the Scala programming language
• BIDMach - CPU and GPU-accelerated Machine Learning Library.
• Figaro - a Scala library for constructing probabilistic models.
• H2O Sparkling Water - H2O and Spark interoperability.
• DynaML - Scala Library/REPL for Machine Learning Research
• Saul - Flexible Declarative Learning-Based Programming.
• SwiftLearner - Simply written algorithms to help study ML or write your own implementations.

### Swift¶

General-Purpose Machine Learning

• Swift AI - Highly optimized artificial intelligence and machine learning library written in Swift.
• BrainCore - The iOS and OS X neural network framework
• swix - A bare bones library that includes a general matrix language and wraps some OpenCV for iOS development.
• DeepLearningKit an Open Source Deep Learning Framework for Apple’s iOS, OS X and tvOS. It currently allows using deep convolutional neural network models trained in Caffe on Apple operating systems.
• AIToolbox - A toolbox framework of AI modules written in Swift: Graphs/Trees, Linear Regression, Support Vector Machines, Neural Networks, PCA, KMeans, Genetic Algorithms, MDP, Mixture of Gaussians.
• MLKit - A simple Machine Learning Framework written in Swift. Currently features Simple Linear Regression, Polynomial Regression, and Ridge Regression.
• Swift Brain - The first neural network / machine learning library written in Swift. This is a project for AI algorithms in Swift for iOS and OS X development. This project includes algorithms focused on Bayes theorem, neural networks, SVMs, Matrices, etc..

## Papers¶

### Machine Learning¶

Be the first to contribute!

### Deep Learning¶

Forked from terryum’s awesome deep learning papers.

#### Understanding¶

• Distilling the knowledge in a neural network (2015), G. Hinton et al. [pdf]
• Deep neural networks are easily fooled: High confidence predictions for unrecognizable images (2015), A. Nguyen et al. [pdf]
• How transferable are features in deep neural networks? (2014), J. Yosinski et al. [pdf]
• CNN features off-the-Shelf: An astounding baseline for recognition (2014), A. Razavian et al. [pdf]
• Learning and transferring mid-Level image representations using convolutional neural networks (2014), M. Oquab et al. [pdf]
• Visualizing and understanding convolutional networks (2014), M. Zeiler and R. Fergus [pdf]
• Decaf: A deep convolutional activation feature for generic visual recognition (2014), J. Donahue et al. [pdf]

#### Optimization / Training Techniques¶

• Batch normalization: Accelerating deep network training by reducing internal covariate shift (2015), S. Loffe and C. Szegedy [pdf]
• Delving deep into rectifiers: Surpassing human-level performance on imagenet classification (2015), K. He et al. [pdf]
• Dropout: A simple way to prevent neural networks from overfitting (2014), N. Srivastava et al. [pdf]
• Adam: A method for stochastic optimization (2014), D. Kingma and J. Ba [pdf]
• Improving neural networks by preventing co-adaptation of feature detectors (2012), G. Hinton et al. [pdf]
• Random search for hyper-parameter optimization (2012) J. Bergstra and Y. Bengio [pdf]

#### Unsupervised / Generative Models¶

• Pixel recurrent neural networks (2016), A. Oord et al. [pdf]
• Improved techniques for training GANs (2016), T. Salimans et al. [pdf]
• Unsupervised representation learning with deep convolutional generative adversarial networks (2015), A. Radford et al. [pdf]
• DRAW: A recurrent neural network for image generation (2015), K. Gregor et al. [pdf]
• Generative adversarial nets (2014), I. Goodfellow et al. [pdf]
• Auto-encoding variational Bayes (2013), D. Kingma and M. Welling [pdf]
• Building high-level features using large scale unsupervised learning (2013), Q. Le et al. [pdf]

#### Image Segmentation / Object Detection¶

• You only look once: Unified, real-time object detection (2016), J. Redmon et al. [pdf]
• Fully convolutional networks for semantic segmentation (2015), J. Long et al. [pdf]
• Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks (2015), S. Ren et al. [pdf]
• Fast R-CNN (2015), R. Girshick [pdf]
• Rich feature hierarchies for accurate object detection and semantic segmentation (2014), R. Girshick et al. [pdf]
• Semantic image segmentation with deep convolutional nets and fully connected CRFs, L. Chen et al. [pdf]
• Learning hierarchical features for scene labeling (2013), C. Farabet et al. [pdf]

#### Image / Video¶

• Image Super-Resolution Using Deep Convolutional Networks (2016), C. Dong et al. [pdf]
• A neural algorithm of artistic style (2015), L. Gatys et al. [pdf]
• Deep visual-semantic alignments for generating image descriptions (2015), A. Karpathy and L. Fei-Fei [pdf]
• Show, attend and tell: Neural image caption generation with visual attention (2015), K. Xu et al. [pdf]
• Show and tell: A neural image caption generator (2015), O. Vinyals et al. [pdf]
• Long-term recurrent convolutional networks for visual recognition and description (2015), J. Donahue et al. [pdf]
• VQA: Visual question answering (2015), S. Antol et al. [pdf]
• DeepFace: Closing the gap to human-level performance in face verification (2014), Y. Taigman et al. [pdf]:
• Large-scale video classification with convolutional neural networks (2014), A. Karpathy et al. [pdf]
• DeepPose: Human pose estimation via deep neural networks (2014), A. Toshev and C. Szegedy [pdf]
• Two-stream convolutional networks for action recognition in videos (2014), K. Simonyan et al. [pdf]
• 3D convolutional neural networks for human action recognition (2013), S. Ji et al. [pdf]

#### Natural Language Processing¶

• Neural Architectures for Named Entity Recognition (2016), G. Lample et al. [pdf]
• Exploring the limits of language modeling (2016), R. Jozefowicz et al. [pdf]
• Teaching machines to read and comprehend (2015), K. Hermann et al. [pdf]
• Effective approaches to attention-based neural machine translation (2015), M. Luong et al. [pdf]
• Conditional random fields as recurrent neural networks (2015), S. Zheng and S. Jayasumana. [pdf]
• Memory networks (2014), J. Weston et al. [pdf]
• Neural turing machines (2014), A. Graves et al. [pdf]
• Neural machine translation by jointly learning to align and translate (2014), D. Bahdanau et al. [pdf]
• Sequence to sequence learning with neural networks (2014), I. Sutskever et al. [pdf]
• Learning phrase representations using RNN encoder-decoder for statistical machine translation (2014), K. Cho et al. [pdf]
• A convolutional neural network for modeling sentences (2014), N. Kalchbrenner et al. [pdf]
• Convolutional neural networks for sentence classification (2014), Y. Kim [pdf]
• Glove: Global vectors for word representation (2014), J. Pennington et al. [pdf]
• Distributed representations of sentences and documents (2014), Q. Le and T. Mikolov [pdf]
• Distributed representations of words and phrases and their compositionality (2013), T. Mikolov et al. [pdf]
• Efficient estimation of word representations in vector space (2013), T. Mikolov et al. [pdf]
• Recursive deep models for semantic compositionality over a sentiment treebank (2013), R. Socher et al. [pdf]
• Generating sequences with recurrent neural networks (2013), A. Graves. [pdf]

#### Speech / Other¶

• End-to-end attention-based large vocabulary speech recognition (2016), D. Bahdanau et al. [pdf]
• Deep speech 2: End-to-end speech recognition in English and Mandarin (2015), D. Amodei et al. [pdf]
• Speech recognition with deep recurrent neural networks (2013), A. Graves [pdf]
• Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups (2012), G. Hinton et al. [pdf]
• Context-dependent pre-trained deep neural networks for large-vocabulary speech recognition (2012) G. Dahl et al. [pdf]
• Acoustic modeling using deep belief networks (2012), A. Mohamed et al. [pdf]

#### Reinforcement Learning¶

• End-to-end training of deep visuomotor policies (2016), S. Levine et al. [pdf]
• Learning Hand-Eye Coordination for Robotic Grasping with Deep Learning and Large-Scale Data Collection (2016), S. Levine et al. [pdf]
• Asynchronous methods for deep reinforcement learning (2016), V. Mnih et al. [pdf]
• Deep Reinforcement Learning with Double Q-Learning (2016), H. Hasselt et al. [pdf]
• Mastering the game of Go with deep neural networks and tree search (2016), D. Silver et al. [pdf]
• Continuous control with deep reinforcement learning (2015), T. Lillicrap et al. [pdf]
• Human-level control through deep reinforcement learning (2015), V. Mnih et al. [pdf]
• Deep learning for detecting robotic grasps (2015), I. Lenz et al. [pdf]
• Playing atari with deep reinforcement learning (2013), V. Mnih et al. [pdf]

#### New papers¶

• Deep Photo Style Transfer (2017), F. Luan et al. [pdf]
• Evolution Strategies as a Scalable Alternative to Reinforcement Learning (2017), T. Salimans et al. [pdf]
• Deformable Convolutional Networks (2017), J. Dai et al. [pdf]
• Mask R-CNN (2017), K. He et al. [pdf]
• Learning to discover cross-domain relations with generative adversarial networks (2017), T. Kim et al. [pdf]
• Deep voice: Real-time neural text-to-speech (2017), S. Arik et al., [pdf]
• PixelNet: Representation of the pixels, by the pixels, and for the pixels (2017), A. Bansal et al. [pdf]
• Batch renormalization: Towards reducing minibatch dependence in batch-normalized models (2017), S. Ioffe. [pdf]
• Wasserstein GAN (2017), M. Arjovsky et al. [pdf]
• Understanding deep learning requires rethinking generalization (2017), C. Zhang et al. [pdf]
• Least squares generative adversarial networks (2016), X. Mao et al. [pdf]

#### Classic Papers¶

• An analysis of single-layer networks in unsupervised feature learning (2011), A. Coates et al. [pdf]
• Deep sparse rectifier neural networks (2011), X. Glorot et al. [pdf]
• Natural language processing (almost) from scratch (2011), R. Collobert et al. [pdf]
• Recurrent neural network based language model (2010), T. Mikolov et al. [pdf]
• Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion (2010), P. Vincent et al. [pdf]
• Learning mid-level features for recognition (2010), Y. Boureau [pdf]
• A practical guide to training restricted boltzmann machines (2010), G. Hinton [pdf]
• Understanding the difficulty of training deep feedforward neural networks (2010), X. Glorot and Y. Bengio [pdf]
• Why does unsupervised pre-training help deep learning (2010), D. Erhan et al. [pdf]
• Learning deep architectures for AI (2009), Y. Bengio. [pdf]
• Convolutional deep belief networks for scalable unsupervised learning of hierarchical representations (2009), H. Lee et al. [pdf]
• Greedy layer-wise training of deep networks (2007), Y. Bengio et al. [pdf]
• A fast learning algorithm for deep belief nets (2006), G. Hinton et al. [pdf]
• Gradient-based learning applied to document recognition (1998), Y. LeCun et al. [pdf]
• Long short-term memory (1997), S. Hochreiter and J. Schmidhuber. [pdf]

## Other Content¶

Books, blogs, courses and more forked from josephmisiti’s awesome machine learning

### Tutorials¶

Be the first to contribute!