проверь правильность моего кода и исправь если что
main.py:
import numpy as np
import pickle

# Загрузка данных из файлов
with open("dataset_features.pkl", "rb") as f:
    dataset_features = pickle.load(f)

with open("outputs.pkl", "rb") as f:
    outputs = pickle.load(f)

# Нормализация данных (важно для устойчивого обучения сети)
dataset_features = dataset_features / np.max(dataset_features)

# Параметры сети
input_size = dataset_features.shape[1]  # Количество признаков (360 корзин гистограммы)
hidden_size = 64  # Количество нейронов в скрытом слое
output_size = len(np.unique(outputs))  # Количество классов (4 фрукта)

# Инициализация весов
np.random.seed(42)  # Для повторяемости результатов
W1 = np.random.randn(input_size, hidden_size)
b1 = np.zeros(hidden_size)
W2 = np.random.randn(hidden_size, output_size)
b2 = np.zeros(output_size)


# Функция активации и её производная (ReLU)
def relu(x):
    return np.maximum(0, x)


def relu_derivative(x):
    return x > 0


# Softmax для выходного слоя
def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=1, keepdims=True)


# Функция потерь (кросс-энтропия)
def cross_entropy_loss(y_pred, y_true):
    m = y_true.shape[0]
    p = softmax(y_pred)
    log_likelihood = -np.log(p[range(m), y_true.astype(int)])
    return np.sum(log_likelihood) / m


# Прямое распространение
def forward_pass(X):
    global W1, b1, W2, b2
    Z1 = X.dot(W1) + b1
    A1 = relu(Z1)
    Z2 = A1.dot(W2) + b2
    return Z1, A1, Z2


# Обратное распространение
def backward_pass(X, y, Z1, A1, Z2, learning_rate=0.001):
    global W1, b1, W2, b2
    m = y.shape[0]
    y_pred = softmax(Z2)

    # Градиенты для выходного слоя
    dZ2 = y_pred
    dZ2[range(m), y.astype(int)] -= 1
    dZ2 /= m

    # Обновление весов и смещений для второго слоя
    dW2 = A1.T.dot(dZ2)
    db2 = np.sum(dZ2, axis=0)
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2

    # Градиенты для скрытого слоя
    dA1 = dZ2.dot(W2.T)
    dZ1 = dA1 * relu_derivative(Z1)
    dW1 = X.T.dot(dZ1)
    db1 = np.sum(dZ1, axis=0)

    # Обновление весов и смещений для первого слоя
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1


# Обучение модели
def train(X, y, epochs=1000, learning_rate=0.001):
    for epoch in range(epochs):
        Z1, A1, Z2 = forward_pass(X)
        loss = cross_entropy_loss(Z2, y)
        if epoch % 100 == 0:
            print(f"Epoch {epoch}, Loss: {loss}")
        backward_pass(X, y, Z1, A1, Z2, learning_rate)


# Оценка точности модели
def predict(X):
    _, _, Z2 = forward_pass(X)
    y_pred = np.argmax(softmax(Z2), axis=1)
    return y_pred


def accuracy(y_pred, y_true):
    return np.mean(y_pred == y_true) * 100


# Обучение модели
train(dataset_features, outputs, epochs=1000, learning_rate=0.001)

# Проверка точности на обучающем наборе
predictions = predict(dataset_features)
acc = accuracy(predictions, outputs)
print(f"Training Accuracy: {acc}%")

init.py:
import numpy
import skimage.io
import skimage.feature
import os
import pickle

fruits = ["Avocado", "Cherry", "Cocos", "Onion Red"]
# 427+492+490+450=1859
dataset_features = numpy.zeros(shape=(1859, 360))
outputs = numpy.zeros(shape=1859)

idx = 0
class_label = 0
for fruit_dir in fruits:
    curr_dir = os.path.join(os.path.sep, fruit_dir)
    all_images = os.listdir(os.getcwd()+curr_dir)
    for img_file in all_images:
        if img_file.endswith(".jpg"):  # Ensures reading only JPG files.
            fruit_data = skimage.io.imread(fname=os.getcwd()+curr_dir+'\\'+img_file)
            fruit_data_hsv = skimage.color.rgb2hsv(rgb=fruit_data)
            hist = numpy.histogram(a=fruit_data_hsv[:, :, 0], bins=360)
            dataset_features[idx, :] = hist[0]
            outputs[idx] = class_label
            idx = idx + 1
    class_label = class_label + 1

with open("dataset_features.pkl", "wb") as f:
    pickle.dump(dataset_features, f)

with open("outputs.pkl", "wb") as f:
    pickle.dump(outputs, f)