Я создал собственную простую 1-слойную нейронную сеть, специализирующуюся на задачах двоичной классификации. Где входные точки данных умножаются на веса и добавляется смещение. Все это суммируется (взвешенная сумма) и подается через функцию активации (например, relu или sigmoid). Это было бы результатом прогноза. Никаких других слоев (то есть скрытых слоев) не задействовано.
Просто для собственного понимания математической стороны я не хотел использовать существующую библиотеку / пакет (например, Keras, PyTorch, Scikit-learn ..etc), но просто хотел создать нейронную сеть с использованием простого Python код. Модель создается внутри метода (simple_1_layer_classification_NN), который принимает необходимые параметры для прогнозирования. Тем не менее, я столкнулся с некоторыми проблемами, и поэтому перечислил вопросы ниже вместе с моим кодом.
P.s. Я действительно извиняюсь за включение такой большой части кода, но я не знал, как еще задавать вопросы, не ссылаясь на соответствующий код.
Вопросы:
1 - Когда я передал некоторый набор обучающих данных для обучения сети, я обнаружил, что окончательная средняя точность полностью отличалась при различном количестве эпох, абсолютно не имея четкой схемы с каким-либо оптимальным числом эпох. Я оставил остальные параметры такими же: learning rate = 0.5, activation = sigmoid (так как это 1 слой, являющийся одновременно входным и выходным слоями. Никаких скрытых слоев не используется. Я прочитал sigmoid подходит для выходного слоя больше, чем relu), cost function = squared error. Вот результаты для разных эпох:
Эпоха = 100 000
Средняя точность: 50.10541638874056
Эпоха = 500 000.
Средняя точность: 50.08965597645948
Эпоха = 1 000 000.
Средняя точность: 97,56879179064482
Эпоха = 7500000.
Средняя точность: 49.994692515332524
Эпоха 750 000.
Средняя точность: 77.0028368954157
Эпоха = 100.
Средняя точность: 48,96967591507596
Эпоха = 500.
Средняя точность: 48.20721972881673
Эпоха = 10000.
Средняя точность: 71.58066454336122
Эпоха = 50000.
Средняя точность: 62,52998222597177
Эпоха = 100 000
Средняя точность: 49,813675726563424
Эпоха = 1 000 000.
Средняя точность: 49.993141329926374
Как видите, четкой картины, похоже, нет. Я пробовал 1 миллион эпох и получил точность 97,6%. Тогда я попробовал 7,5 миллионов эпох, получил 50% точности. Полмиллиона эпох также получили 50% точности. 100 эпох дали точность 49%. Тогда действительно странный, перепробовал 1 миллион эпох и получил 50%.
Итак, я делюсь своим кодом ниже, потому что я не верю, что сеть занимается обучением. Просто кажется, что случайные догадки. Я применил концепцию обратного распространения и частной производной для оптимизации весов и смещений. Так что я не уверен, где я ошибаюсь с моим кодом.
2- Одним из параметров, которые я включил в список параметров метода simple_1_layer_classification_NN, является параметр input_dimension. Сначала я подумал, что нужно будет рассчитать количество весов, необходимое для входного слоя. Затем я понял, что пока аргумент dataset_input_matrix (матрица признаков) передается методу, я могу получить доступ к случайному индексу матрицы, чтобы получить доступ к случайному вектору наблюдения из матрицы (input_observation_vector = dataset_input_matrix[ri]). Затем пройдитесь по наблюдению, чтобы получить доступ к каждой функции. Количество петель (или длина) вектора наблюдения скажет мне, сколько именно весов требуется (потому что для каждого объекта потребуется один вес (как его коэффициент). Так что (len(input_observation_vector)) сообщит мне количество весов, необходимое во входных данных. слой, и поэтому мне не нужно просить пользователя передать input_dimension аргумент методу.
Поэтому мой вопрос заключается в том, есть ли необходимость / причина для включения параметра input_dimension, когда это можно решить, просто оценив длину вектора наблюдения из входной матрицы?
3 - Когда я пытаюсь построить массив значений costs, ничего не появляется - plt.plot(y_costs). Значение cost (создается из каждой эпохи) добавляется к массиву costs только каждые 50 эпох. Это позволяет избежать добавления в массив стольких cost элементов, если количество эпох действительно велико. В строке:
if i % 50 == 0:
costs.append(cost)
Когда я выполнил некоторую отладку, я обнаружил, что массив costs пуст после завершения метода. Я не уверен, почему это так, когда он должен добавлять значение cost каждую 50-ю эпоху. Возможно, я упустил из виду что-то действительно глупое, что не вижу этого.
Большое спасибо заранее, и еще раз извиняюсь за длинный кусок кода.
from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
import sys
# import os
class NN_classification:
def __init__(self):
self.bias = float()
self.weights = []
self.chosen_activation_func = None
self.chosen_cost_func = None
self.train_average_accuracy = int()
self.test_average_accuracy = int()
# -- Activation functions --:
def sigmoid(x):
return 1/(1 + np.exp(-x))
def relu(x):
return np.maximum(0.0, x)
# -- Derivative of activation functions --:
def sigmoid_derivation(x):
return NN_classification.sigmoid(x) * (1-NN_classification.sigmoid(x))
def relu_derivation(x):
if x <= 0:
return 0
else:
return 1
# -- Squared-error cost function --:
def squared_error(pred, target):
return np.square(pred - target)
# -- Derivative of squared-error cost function --:
def squared_error_derivation(pred, target):
return 2 * (pred - target)
# --- neural network structure diagram ---
# O output prediction
# / \ w1, w2, b
# O O datapoint 1, datapoint 2
def simple_1_layer_classification_NN(self, dataset_input_matrix, output_data_labels, input_dimension, epochs, activation_func='sigmoid', learning_rate=0.2, cost_func='squared_error'):
weights = []
bias = int()
cost = float()
costs = []
dCost_dWeights = []
chosen_activation_func_derivation = None
chosen_cost_func = None
chosen_cost_func_derivation = None
correct_pred = int()
incorrect_pred = int()
# store the chosen activation function to use to it later on in the activation calculation section and in the 'predict' method
# Also the same goes for the derivation section.
if activation_func == 'sigmoid':
self.chosen_activation_func = NN_classification.sigmoid
chosen_activation_func_derivation = NN_classification.sigmoid_derivation
elif activation_func == 'relu':
self.chosen_activation_func = NN_classification.relu
chosen_activation_func_derivation = NN_classification.relu_derivation
else:
print("Exception error - no activation function utilised, in training method", file=sys.stderr)
return
# store the chosen cost function to use to it later on in the cost calculation section.
# Also the same goes for the cost derivation section.
if cost_func == 'squared_error':
chosen_cost_func = NN_classification.squared_error
chosen_cost_func_derivation = NN_classification.squared_error_derivation
else:
print("Exception error - no cost function utilised, in training method", file=sys.stderr)
return
# Set initial network parameters (weights & bias):
# Will initialise the weights to a uniform distribution and ensure the numbers are small close to 0.
# We need to loop through all the weights to set them to a random value initially.
for i in range(input_dimension):
# create random numbers for our initial weights (connections) to begin with. 'rand' method creates small random numbers.
w = np.random.rand()
weights.append(w)
# create a random number for our initial bias to begin with.
bias = np.random.rand()
# We perform the training based on the number of epochs specified
for i in range(epochs):
# create random index
ri = np.random.randint(len(dataset_input_matrix))
# Pick random observation vector: pick a random observation vector of independent variables (x) from the dataset matrix
input_observation_vector = dataset_input_matrix[ri]
# reset weighted sum value at the beginning of every epoch to avoid incrementing the previous observations weighted-sums on top.
weighted_sum = 0
# Loop through all the independent variables (x) in the observation
for i in range(len(input_observation_vector)):
# Weighted_sum: we take each independent variable in the entire observation, add weight to it then add it to the subtotal of weighted sum
weighted_sum += input_observation_vector[i] * weights[i]
# Add Bias: add bias to weighted sum
weighted_sum += bias
# Activation: process weighted_sum through activation function
activation_func_output = self.chosen_activation_func(weighted_sum)
# Prediction: Because this is a single layer neural network, so the activation output will be the same as the prediction
pred = activation_func_output
# Cost: the cost function to calculate the prediction error margin
cost = chosen_cost_func(pred, output_data_labels[ri])
# Also calculate the derivative of the cost function with respect to prediction
dCost_dPred = chosen_cost_func_derivation(pred, output_data_labels[ri])
# Derivative: bringing derivative from prediction output with respect to the activation function used for the weighted sum.
dPred_dWeightSum = chosen_activation_func_derivation(weighted_sum)
# Bias is just a number on its own added to the weighted sum, so its derivative is just 1
dWeightSum_dB = 1
# The derivative of the Weighted Sum with respect to each weight is the input data point / independant variable it's multiplied by.
# Therefore I simply assigned the input data array to another variable I called 'dWeightedSum_dWeights'
# to represent the array of the derivative of all the weights involved. I could've used the 'input_sample'
# array variable itself, but for the sake of readibility, I created a separate variable to represent the derivative of each of the weights.
dWeightedSum_dWeights = input_observation_vector
# Derivative chaining rule: chaining all the derivative functions together (chaining rule)
# Loop through all the weights to workout the derivative of the cost with respect to each weight:
for dWeightedSum_dWeight in dWeightedSum_dWeights:
dCost_dWeight = dCost_dPred * dPred_dWeightSum * dWeightedSum_dWeight
dCost_dWeights.append(dCost_dWeight)
dCost_dB = dCost_dPred * dPred_dWeightSum * dWeightSum_dB
# Backpropagation: update the weights and bias according to the derivatives calculated above.
# In other word we update the parameters of the neural network to correct parameters and therefore
# optimise the neural network prediction to be as accurate to the real output as possible
# We loop through each weight and update it with its derivative with respect to the cost error function value.
for i in range(len(weights)):
weights[i] = weights[i] - learning_rate * dCost_dWeights[i]
bias = bias - learning_rate * dCost_dB
# for each 50th loop we're going to get a summary of the
# prediction compared to the actual ouput
# to see if the prediction is as expected.
# Anything in prediction above 0.5 should match value
# 1 of the actual ouptut. Any prediction below 0.5 should
# match value of 0 for actual output
if i % 50 == 0:
costs.append(cost)
# Compare prediction to target
error_margin = np.sqrt(np.square(pred - output_data_labels[ri]))
accuracy = (1 - error_margin) * 100
self.train_average_accuracy += accuracy
# Evaluate whether guessed correctly or not based on classification binary problem 0 or 1 outcome. So if prediction is above 0.5 it guessed 1 and below 0.5 it guessed incorrectly. If it's dead on 0.5 it is incorrect for either guesses. Because it's no exactly a good guess for either 0 or 1. We need to set a good standard for the neural net model.
if (error_margin < 0.5) and (error_margin >= 0):
correct_pred += 1
elif (error_margin >= 0.5) and (error_margin <= 1):
incorrect_pred += 1
else:
print("Exception error - 'margin error' for 'predict' method is out of range. Must be between 0 and 1, in training method", file=sys.stderr)
return
# store the final optimised weights to the weights instance variable so it can be used in the predict method.
self.weights = weights
# store the final optimised bias to the weights instance variable so it can be used in the predict method.
self.bias = bias
# Calculate average accuracy from the predictions of all obervations in the training dataset
self.train_average_accuracy /= epochs
# Print out results
print('Average Accuracy: {}'.format(self.train_average_accuracy))
print('Correct predictions: {}, Incorrect Predictions: {}'.format(correct_pred, incorrect_pred))
print('costs = {}'.format(costs))
y_costs = np.array(costs)
plt.plot(y_costs)
plt.show()
from numpy import array
#define array of dataset
# each observation vector has 3 datapoints or 3 columns: length, width, and outcome label (0, 1 to represent blue flower and red flower respectively).
data = array([[3, 1.5, 1],
[2, 1, 0],
[4, 1.5, 1],
[3, 1, 0],
[3.5, 0.5, 1],
[2, 0.5, 0],
[5.5, 1, 1],
[1, 1, 0]])
# separate data: split input, output, train and test data.
X_train, y_train, X_test, y_test = data[:6, :-1], data[:6, -1], data[6:, :-1], data[6:, -1]
nn_model = NN_classification()
nn_model.simple_1_layer_classification_NN(X_train, y_train, 2, 1000000, learning_rate=0.5)