Начало работы с машинным обучением: разработайте свою первую нейронную сеть с помощью Python

Вот что может вас удивить:нейронные сети не так уж сложны!Термин «нейронная сеть» часто используется как модное слово, но на самом деле они часто намного проще, чем люди себе представляют.

This post is intended for complete beginners and assumes ZERO prior knowledge of machine learningМы поймем, как работают нейронные сети, реализуя их с нуля на Python.

Давайте начнем!

1. Building Blocks: Neurons

First, we have to talk about neurons, the basic unit of a neural network. A neuron takes inputs, does some math with them, and produces one outputВот как выглядит нейрон с двумя входами:

3 things are happening here. First, each input is multiplied by a weight:

Next, all the weighted inputs are added together with a bias bbb:

Finally, the sum is passed through an activation function:

The activation function is used to turn an unbounded input into an output that has a nice, predictable form. A commonly used activation function is the sigmoid function:

The sigmoid function only outputs numbers in the range (0,1)(0, 1)(0,1). You can think of it as compressing (−∞,+∞)(-\infty, +\infty)(−∞,+∞) to (0,1)(0, 1)(0,1) - big negative numbers become ~000, and big positive numbers become ~111.

A Simple Example

Assume we have a 2-input neuron that uses the sigmoid activation function and has the following parameters:

w=[0,1]w = [0, 1]w=[0,1] is just a way of writing w1=0,w2=1w_1 = 0, w_2 = 1w1​=0,w2​=1в векторной форме Теперь давайте подадим на вход нейронуx=[2,3]x = [2, 3]x=[2,3], Мы будем использоватьdot product to write things more concisely:

The neuron outputs 0.9990.9990.999 given the inputs x=[2,3]x = [2, 3]x=[2,3], Вот и все!Этот процесс передачи входных данных для получения выходных данных известен какfeedforward.

Coding a Neuron

Время реализовать нейрон! Мы будем использоватьNumPy, a popular and powerful computing library for Python, to help us do math:

import numpy as np

def sigmoid(x):
  # Our activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

class Neuron:
  def __init__(self, weights, bias):
    self.weights = weights
    self.bias = bias

  def feedforward(self, inputs):
    # Weight inputs, add bias, then use the activation function
    total = np.dot(self.weights, inputs) + self.bias
    return sigmoid(total)

weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4                   # b = 4
n = Neuron(weights, bias)

x = np.array([2, 3])       # x1 = 2, x2 = 3
print(n.feedforward(x))    # 0.9990889488055994

Узнаете эти числа? Это пример, который мы только что сделали! Мы получаем тот же ответ0.9990.9990.999.

2. Combining Neurons into a Neural Network

Нейронная сеть — это не что иное, как набор нейронов, соединенных вместе Вот как может выглядеть простая нейронная сеть:

This network has 2 inputs, a hidden layer with 2 neurons (h1h_1h1​ and h2h_2h2​), and an output layer with 1 neuron (o1o_1o1​). Notice that the inputs for o1o_1o1​ are the outputs from h1h_1h1​ and h2h_2h2​- вот что делает это сетью.

A hidden layer is any layer between the input (first) layer and output (last) layer. There can be multiple hidden layers!

An Example: Feedforward

Давайте используем сеть, изображенную выше, и предположим, что все нейроны имеют одинаковые веса.w=[0,1]w = [0, 1]w=[0,1], the same bias b=0b = 0b=0, and the same sigmoid activation function. Let h1,h2,o1h_1, h_2, o_1h1​,h2​,o1​ denote the outputs of the neurons they represent.

What happens if we pass in the input x=[2,3]x = [2, 3]x=[2,3]?

The output of the neural network for input x=[2,3]x = [2, 3]x=[2,3] is 0.72160.72160.7216. Pretty simple, right?

A neural network can have any number of layers with any number of neuronsв этих слоях. Основная идея остается прежней: подавайте входные данные вперед через нейроны в сети, чтобы получить выходные данные в конце. Для простоты мы будем продолжать использовать сеть, изображенную выше, для остальных этого поста.

Coding a Neural Network: Feedforward

Давайте реализуем прямую связь для нашей нейронной сети.Вот снова изображение сети для справки:

import numpy as np

# ... code from previous section here

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)
  Each neuron has the same weights and bias:
    - w = [0, 1]
    - b = 0
  '''
  def __init__(self):
    weights = np.array([0, 1])
    bias = 0

    # The Neuron class here is from the previous section
    self.h1 = Neuron(weights, bias)
    self.h2 = Neuron(weights, bias)
    self.o1 = Neuron(weights, bias)

  def feedforward(self, x):
    out_h1 = self.h1.feedforward(x)
    out_h2 = self.h2.feedforward(x)

    # The inputs for o1 are the outputs from h1 and h2
    out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))

    return out_o1

network = OurNeuralNetwork()
x = np.array([2, 3])
print(network.feedforward(x)) # 0.7216325609518421

We got 0.72160.72160.7216 again! Looks like it works.

3. Training a Neural Network, Part 1

Say we have the following measurements:

Давайте обучим нашу сеть предсказывать чей-то пол по его весу и росту:

Мы будем представлять Мале с000 and Female with a 111, а также сдвинем данные, чтобы их было проще использовать:

I arbitrarily chose the shift amounts (135135135 and 666666), чтобы числа выглядели красиво.Обычно вы бы сдвигались на среднее значение.

Loss

Прежде чем мы будем обучать нашу сеть, нам сначала нужен способ количественной оценки того, насколько «хорошо» она работает, чтобы она могла попытаться сделать «лучше».loss is.

Мы будем использоватьmean squared error (MSE) loss:

Давайте разберем это:

• nnn is the number of samples, which is 444 (Alice, Bob, Charlie, Diana).
• yyy represents the variable being predicted, which is Gender.
• ytruey_{true}ytrue​ is the trueзначение переменной («правильный ответ»). Например,ytruey_{true}ytrue​ for Alice would be 111 (Female).
• ypredy_{pred}ypred​ is the predictedзначение переменной Это то, что выводит наша сеть.

(ytrue-ypred)2(y_{true} - y_{pred})^2(ytrue​−ypred​)2 is known as the squared error. Our loss function is simply taking the average over all squared errors (hence the name mean squared error). The better our predictions are, the lower our loss will be!

Better predictions = Lower loss.

Training a network = trying to minimize its loss.

An Example Loss Calculation

Допустим, наша сеть всегда выводит000- другими словами, он уверен, что все люди - мужчины ? В чем будет наша потеря?

Code: MSE Loss

Вот некоторый код для расчета потерь для нас:

import numpy as np

def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  return ((y_true - y_pred) ** 2).mean()

y_true = np.array([1, 0, 0, 1])
y_pred = np.array([0, 0, 0, 0])

print(mse_loss(y_true, y_pred)) # 0.5

Nice. Onwards!

4. Training a Neural Network, Part 2

We now have a clear goal: minimize the lossМы знаем, что можем изменить веса и смещения сети, чтобы повлиять на ее прогнозы, но как нам это сделать, чтобы уменьшить потери?

В этом разделе используется немного многомерного исчисления.Если вы не знакомы с исчислением, не стесняйтесь пропустить математические части.

Для простоты предположим, что в нашем наборе данных есть только Алиса:

Тогда потеря среднеквадратичной ошибки — это просто квадрат ошибки Алисы:

Другой способ думать о потерях - как функция весов и смещений.Давайте обозначим каждый вес и смещение в нашей сети:

Then, we can write loss as a multivariable function:

Imagine we wanted to tweak w1w_1w1​. How would loss LLL change if we changed w1w_1w1​Это вопросpartial derivative ∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​ can answer. How do we calculate it?

Вот где математика начинает становиться более сложной.Не отчаивайтесь!Я рекомендую взять ручку и бумагу — это поможет вам понять.

Для начала перепишем частную производную через∂ypred∂w1\frac{\partial y_{pred}}{\partial w_1}∂w1​∂ypred​​ instead:

We can calculate ∂L∂yпред \ гидроразрыва {\ парциальное L} {\ парциальное y_ {пред}}∂ypred​∂L​ because we computed L=(1−yпред)2L = (1 - y_{пред})^2L=(1−ypred​)2 above:

Теперь давайте разберемся, что делать с∂ypred∂w1\frac{\partial y_{pred}}{\partial w_1}∂w1​∂ypred​​. Just like before, let h1,h2,o1h_1, h_2, o_1h1​,h2​,o1​ be the outputs of the neurons they represent. Then

Since w1w_1w1​ only affects h1h_1h1​ (not h2h_2h2​), we can write

We do the same thing for ∂h1∂w1 \ гидроразрыва {\ парциальное h_1} {\ парциальное w_1}∂w1​∂h1​​:

x1x_1x1​ here is weight, and x2x_2x2​это высота. Это второй раз, когда мы видимf'(х)f'(х)f'(x)(производная сигмовидной функции) теперь! Давайте выведем это:

Мы будем использовать эту красивую форму дляf'(х)f'(х)f'(x) later.

Готово! Нам удалось сломаться.∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​ into several parts we can calculate:

This system of calculating partial derivatives by working backwards is known as backpropagation, или "бэкпроп".

Уф. Там было много символов — ничего страшного, если вы все еще немного запутались. Давайте сделаем пример, чтобы увидеть это в действии!

Example: Calculating the Partial Derivative

Мы собираемся продолжать делать вид, что в нашем наборе данных есть только Алиса:

Давайте инициализируем все веса111 and all the biases to 000. If we do a feedforward pass through the network, we get:

The network outputs ypred=0.524y_{pred} = 0.524ypred​=0.524, что не сильно благоприятствует мужчинам (000) or Female (111).Рассчитаем∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​:

Reminder: we derived f'(x)=f(x)∗(1−f(x))f'(x) = f(x) * (1 - f(x))f'(x)=f(x)*(1−f(x)) for our sigmoid activation function earlier.

We did it! This tells us that if we were to increase w1w_1w1​, LLL would increase a tiiiny bit as a result.

Training: Stochastic Gradient Descent

We have all the tools we need to train a neural network now!Мы будем использовать алгоритм оптимизации под названиемstochastic gradient descent(SGD), который говорит нам, как изменить наши веса и смещения, чтобы минимизировать потери, В основном это просто уравнение обновления:

η\etaη is a constant called the learning rateкоторый контролирует, насколько быстро мы тренируемся. Все, что мы делаем, это вычитаемη∂L∂w1 \ эта \ гидроразрыва {\ парциальное L} {\ парциальное w_1}η∂w1​∂L​ from w1w_1w1​:

• If ∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​ is positive, w1w_1w1​ will decrease, which makes LLL decrease.
• If ∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​ is negative, w1w_1w1​ will increase, which makes LLL decrease.

If we do this for every weight and bias in the network, the loss will slowly decrease and our network will improve.

Our training process will look like this:

1. Choose one sample from our dataset. This is what makes it stochastic gradient descent - we only operate on one sample at a time.
2. Calculate all the partial derivatives of loss with respect to weights or biases (e.g. ∂L∂w1 \ гидроразрыва {\ парциальное L} {\ парциальное w_1}∂w1​∂L​, ∂L∂w2 \ гидроразрыва {\ парциальное L} {\ парциальное w_2}∂w2​∂L​, etc).
3. Use the update equation to update each weight and bias.
4. Go back to step 1.

Давайте посмотрим на это в действии!

Code: A Complete Neural Network

Этоfinally time to implement a complete neural network:

import numpy as np

def sigmoid(x):
  # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
  # Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
  fx = sigmoid(x)
  return fx * (1 - fx)

def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)

  *** DISCLAIMER ***:
  The code below is intended to be simple and educational, NOT optimal.
  Real neural net code looks nothing like this. DO NOT use this code.
  Instead, read/run it to understand how this specific network works.
  '''
  def __init__(self):
    # Weights
    self.w1 = np.random.normal()
    self.w2 = np.random.normal()
    self.w3 = np.random.normal()
    self.w4 = np.random.normal()
    self.w5 = np.random.normal()
    self.w6 = np.random.normal()

    # Biases
    self.b1 = np.random.normal()
    self.b2 = np.random.normal()
    self.b3 = np.random.normal()

  def feedforward(self, x):
    # x is a numpy array with 2 elements.
    h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
    h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
    o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
    return o1

  def train(self, data, all_y_trues):
    '''
    - data is a (n x 2) numpy array, n = # of samples in the dataset.
    - all_y_trues is a numpy array with n elements.
      Elements in all_y_trues correspond to those in data.
    '''
    learn_rate = 0.1
    epochs = 1000 # number of times to loop through the entire dataset

    for epoch in range(epochs):
      for x, y_true in zip(data, all_y_trues):
        # --- Do a feedforward (we'll need these values later)
        sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
        h1 = sigmoid(sum_h1)

        sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
        h2 = sigmoid(sum_h2)

        sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
        o1 = sigmoid(sum_o1)
        y_pred = o1

        # --- Calculate partial derivatives.
        # --- Naming: d_L_d_w1 represents "partial L / partial w1"
        d_L_d_ypred = -2 * (y_true - y_pred)

        # Neuron o1
        d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
        d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
        d_ypred_d_b3 = deriv_sigmoid(sum_o1)

        d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
        d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

        # Neuron h1
        d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
        d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
        d_h1_d_b1 = deriv_sigmoid(sum_h1)

        # Neuron h2
        d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
        d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
        d_h2_d_b2 = deriv_sigmoid(sum_h2)

        # --- Update weights and biases
        # Neuron h1
        self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
        self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
        self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

        # Neuron h2
        self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
        self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
        self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

        # Neuron o1
        self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
        self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
        self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

      # --- Calculate total loss at the end of each epoch
      if epoch % 10 == 0:
        y_preds = np.apply_along_axis(self.feedforward, 1, data)
        loss = mse_loss(all_y_trues, y_preds)
        print("Epoch %d loss: %.3f" % (epoch, loss))

# Define dataset
data = np.array([
  [-2, -1],  # Alice
  [25, 6],   # Bob
  [17, 4],   # Charlie
  [-15, -6], # Diana
])
all_y_trues = np.array([
  1, # Alice
  0, # Bob
  0, # Charlie
  1, # Diana
])

# Train our neural network!
network = OurNeuralNetwork()
network.train(data, all_y_trues)

You can run / play with this code yourself.Он также доступен наGithub.

Our loss steadily decreases as the network learns:

We can now use the network to predict genders:

# Make some predictions
emily = np.array([-7, -3]) # 128 pounds, 63 inches
frank = np.array([20, 2])  # 155 pounds, 68 inches
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

Now What?

You made it! A quick recap of what we did:

• Introduced neurons, the building blocks of neural networks.
• Used the sigmoid activation function in our neurons.
• Saw that neural networks are just neurons connected together.
• Created a dataset with Weight and Height as inputs (or features) and Gender as the output (or label).
• Learned about loss functions and the mean squared error (MSE) loss.
• Realized that training a network is just minimizing its loss.
• Used backpropagation to calculate partial derivatives.
• Used stochastic gradient descent (SGD) to train our network.

Еще многое предстоит сделать:

• Experiment with bigger / better neural networks using proper machine learning libraries like Tensorflow, Keras, and PyTorch.
• Tinker with a neural network in your browser.
• Discover other activation functions besides sigmoid.
• Discover other optimizers besides SGD.
• Learn about Convolutional Neural Networks, which revolutionized the field of Computer Vision.
• Learn about Recurrent Neural Networks, often used for Natural Language Processing (NLP).

I may write about these topics or similar ones in the future, so subscribe if you want to get notified about new posts.

Thanks for reading!