Как я могу исправить проблему с logit(expit(50)) = inf в пользовательской модели нейронной сети? ⇐ Python

[Anonymous]

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

• веса ​​— это небольшие числа, такие как значения нейронов и смещения.
• Иногда получаются большие числа, например 50 или 100, когда я складываю все значения нейронов, которые умножаются на веса, а также добавляю смещения. .
• Expit() (сигмоид) этих больших чисел возвращает ровно 1.
• В функции обратного распространения ошибки я использую logit (), чтобы получить производную значений нейрона. поэтому logit(1) возвращает np.inf.
• На следующей итерации некоторые из этих значений inf умножаются на отрицательные веса и получают -inf.
  Значения-inf добавляются к значениям inf, которые составляют nan.
• nan * everything = nan или nan + Everything = nan, поэтому nan достаточно для получения всех значений матриц nan.

как можно Я это исправлю? Прав ли я относительно типа существующей проблемы? Есть ли какие-либо проблемы с кодом, которые я должен знать?
вот код:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.special import expit, logit, softmax

LEARNING_RATE = 0.01
TEST_DATA_AMOUNT = 0.8
EPOCHS = 20
number_of_nodes = [28 * 28, 16, 16, 10]

df = pd.read_csv("5000_records_784I_1O_mnist.csv", index_col=0)
x_data = df.iloc[:, : 28 * 28]
y_data = df.iloc[:, 28 * 28 :]
normalized_x_data = x_data / 255
x_train = normalized_x_data[
: round(TEST_DATA_AMOUNT * len(normalized_x_data))
].to_numpy()
y_train = y_data[: round(TEST_DATA_AMOUNT * len(y_data))].to_numpy()
x_test = normalized_x_data[
round(TEST_DATA_AMOUNT * len(normalized_x_data)) :
].to_numpy()
y_test = y_data[round(TEST_DATA_AMOUNT * len(y_data)) :].to_numpy()

NUMBER_OF_RECORDS = x_train.shape[0]

neuron_values = [np.zeros((number_of_nodes[0], 1))]
weights = []
biases = []
for i in range(1, len(number_of_nodes)):
weights.append(np.random.rand(number_of_nodes, number_of_nodes) * 2 - 1)
biases.append(np.random.rand(number_of_nodes, 1) * 2 - 1)
neuron_values.append(np.zeros((number_of_nodes, 1)))

predicted_outputs = []
network_errors = []

def activate(values, activation_type):
if activation_type == "Sigmoid":
return expit(values)
if activation_type == "ReLU":
return np.maximum(values, 0)
if activation_type == "Softmax":
return softmax(values)
if activation_type == "Tanh":
return np.tanh(values)

def deactivate(values, activation_type):
if activation_type == "Sigmoid":
return logit(values)
if activation_type == "ReLU":
return values > 0
if activation_type == "Softmax":
return values
if activation_type == "Tanh":
return 1 - np.power(values, 2)

def one_hot(value):
one_hot_value = np.zeros((10, 1))
one_hot_value[value] = 1
return one_hot_value

def feed_forward(inputs):
neuron_values[0] = inputs
for j in range(1, len(number_of_nodes) - 1):
neuron_values[j] = activate(
np.matmul(weights[j - 1], neuron_values[j - 1]).reshape(
weights[j - 1].shape[0], 1
)
+ biases[j - 1],
"Sigmoid",
)
neuron_values[j + 1] = activate(
np.matmul(weights[j], neuron_values[j]).reshape(weights[j].shape[0], 1)
+ biases[j],
"Softmax",
)
return neuron_values[-1]

def back_propagate(outputs, targets, learning_rate):
errors = []
gradients = []
for _ in range(1, len(number_of_nodes)):
errors.append([])
gradients.append([])
errors[-1] = 2 * (outputs - targets)
gradients[-1] = learning_rate * (errors[-1] * deactivate(outputs, "Softmax"))
biases[-1] -= gradients[-1]
weights[-1] -= np.matmul(gradients[-1], neuron_values[-2].T)
for j in range(len(number_of_nodes) - 3, -1, -1):
errors[j] = np.matmul(weights[j + 1].T, errors[j + 1])
gradients[j] = (
learning_rate * errors[j] * deactivate(neuron_values[j + 1], "Sigmoid")
)
biases[j] -= gradients[j]
weights[j] -= np.matmul(
gradients[j], neuron_values[j].reshape(neuron_values[j].shape[0], 1).T
)
return outputs - targets

def guess(inputs):
return feed_forward(inputs)

def train(inputs, target, epochs, learning_rate):
for epoch in range(epochs):
p = np.random.permutation(len(inputs))
shuffled_inputs = inputs[p]
shuffled_targets = target[p]
for j, set_of_inputs in enumerate(shuffled_inputs):
epoch_input = set_of_inputs
epoch_target = shuffled_targets[j]
outputs = feed_forward(epoch_input)
error = back_propagate(outputs, one_hot(epoch_target), learning_rate)
sum_of_squared_errors = np.sum(np.power(error, 2))
network_errors.append(sum_of_squared_errors)
# learning_rate *= 0.99
print(
f"Epoch #{epoch+1}: Sum of squared errors: {sum_of_squared_errors}, Target: {epoch_target}, Predict: {outputs.argmax()}"
)

train(x_train, y_train, EPOCHS, LEARNING_RATE)
plt.figure()
plt.plot(network_errors)
plt.grid()
plt.title("Iteration Number vs Error")
plt.xlabel("Iteration Number")
plt.ylabel("Error")
plt.show()
print("Trained weights:")
for layer_weights in weights:
print(layer_weights.shape)
print(layer_weights)
print("Trained biases:")
for layer_biases in biases:
print(layer_biases.shape)
print(layer_biases)



Подробнее здесь: https://stackoverflow.com/questions/784 ... -network-m