Реализация модели ANN с нуля с помощью Numpy - UPROGER

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

ANN является основой прогнозирования и классификации, но широко используется для классификации признаков. Как следует из названия, она построена на основе архитектуры нейронов.

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

Реализация модели ANN с нуля с помощью Numpy — Архитектура ANN – при движении вперед мы применяем фидфорвард, а при возвращении назад применяется обратное распространение, используемое для уменьшения потерь и оптимизации весов.

// Импортирование необходимых библиотек

import numpy as np

// Подготовка набора данных

x = np.array([
    [1,0,1,0],
    [1,0,1,1],
    [0,1,0,1]
])

y = np.array([[1],[1],[0]])

// Определение функции активации

# Activation function 
# Here we have used sigmoid function that gives the output between 0 and 1 
def sigmoid(x):
  return 1/(1+np.exp(-x))

def derivativeSigmoid(x):
  return x * (1 - x)

// Инициализация количества нейронов

# input layer - neurons will be always equal to the number of columns
inputNeurons = x.shape[1]
# hidden neurons - decide by hit and trial
hiddenNeurons = 3
# output neurons - depend on number of classes we have in target column,for eg to classify 0 and 1
outputNeurons = 1

#Инициализация весов и смещений и построение модели ANN

# initializing weights and biases matrices for hidden and output layer randomly
weightsHidden = np.random.uniform(size=(inputNeurons, hiddenNeurons)) 
biasHidden = np.random.uniform(size=(1, hiddenNeurons))
weightsOutput = np.random.uniform(size=(hiddenNeurons, outputNeurons)) 
biasOutput = np.random.uniform(size=(1, outputNeurons))

# learning rate (by hit and trial)
alpha = 0.04 
# number of iterations (by hit and trial)
epochs = 20000

for i in range(epochs):

# Feedforward propagation

  # Step 1 - apply dot product and add bias : f(x) = x.wh + biasHidden
  fx = np.dot(x, weightsHidden) + biasHidden
  # Step 2 - apply activation function
  hiddenLayer = sigmoid(fx)
  # Step 3 - apply dot product and add bias : f(x) = hiddenLayer.wout + biasOut
  fx_ = np.dot(hiddenLayer, weightsOutput) + biasOutput
  # Step 4 - apply activation on output layer
  outputLayer = sigmoid(fx_)

# Backpropagation - loss(y - y^) and optimization of weights and bias

  errorOutput = outputLayer - y 
  # Slope on output layer - derivative of activation function applied on this layer
  slopeOutput = derivativeSigmoid(outputLayer)
  # Delta = error x slope
  deltaOutput = errorOutput * slopeOutput

# for hidden layer
  errorHidden = np.dot(deltaOutput, weightsOutput.T) # T for taking transpose
  slopeHidden = derivativeSigmoid(hiddenLayer)
  deltaHidden = errorHidden * slopeHidden

# updating the weights (weights optimization)
  weightsOutput = weightsOutput - hiddenLayer.T.dot(deltaOutput)*alpha
  weightsHidden = weightsHidden - x.T.dot(deltaHidden)*alpha
  biasOutput = biasOutput - np.sum(deltaOutput)*alpha
  biasHidden = biasHidden - np.sum(deltaOutput)*alpha