fork download
copy 
  1. # your code goes here
  2. import numpy as np
  3.  
  4. class TrainableXNOR:
  5.     def __init__(self, learning_rate=0.5):
  6.         # Увеличиваем начальные веса для лучшей сходимости
  7.         np.random.seed(42)
  8.         self.W1 = np.random.randn(2, 3) * 0.5  # 3 нейрона в скрытом слое
  9.         self.b1 = np.zeros((1, 3))
  10.         self.W2 = np.random.randn(3, 1) * 0.5
  11.         self.b2 = np.zeros((1, 1))
  12.         self.lr = learning_rate
  13.  
  14.     def sigmoid(self, x):
  15.         # Защита от переполнения
  16.         x = np.clip(x, -500, 500)
  17.         return 1 / (1 + np.exp(-x))
  18.  
  19.     def sigmoid_derivative(self, x):
  20.         return x * (1 - x)
  21.  
  22.     def forward(self, X):
  23.         self.z1 = np.dot(X, self.W1) + self.b1
  24.         self.a1 = self.sigmoid(self.z1)
  25.         self.z2 = np.dot(self.a1, self.W2) + self.b2
  26.         self.a2 = self.sigmoid(self.z2)
  27.         return self.a2
  28.  
  29.     def backward(self, X, y, output):
  30.         m = X.shape[0]
  31.  
  32.         # Ошибка выходного слоя
  33.         error_output = output - y
  34.  
  35.         # Градиент выходного слоя
  36.         delta2 = error_output * self.sigmoid_derivative(output)
  37.         dW2 = np.dot(self.a1.T, delta2) / m
  38.         db2 = np.sum(delta2, axis=0, keepdims=True) / m
  39.  
  40.         # Ошибка скрытого слоя
  41.         error_hidden = np.dot(delta2, self.W2.T)
  42.  
  43.         # Градиент скрытого слоя
  44.         delta1 = error_hidden * self.sigmoid_derivative(self.a1)
  45.         dW1 = np.dot(X.T, delta1) / m
  46.         db1 = np.sum(delta1, axis=0, keepdims=True) / m
  47.  
  48.         # Обновление весов
  49.         self.W2 -= self.lr * dW2
  50.         self.b2 -= self.lr * db2
  51.         self.W1 -= self.lr * dW1
  52.         self.b1 -= self.lr * db1
  53.  
  54.     def train(self, X, y, epochs=10000):
  55.         losses = []
  56.         for epoch in range(epochs):
  57.             # Прямой проход
  58.             output = self.forward(X)
  59.  
  60.             # Вычисление ошибки
  61.             loss = np.mean((output - y) ** 2)
  62.             losses.append(loss)
  63.  
  64.             # Обратный проход
  65.             self.backward(X, y, output)
  66.  
  67.             # Вывод прогресса
  68.             if epoch % 2000 == 0:
  69.                 predictions = output.flatten()
  70.                 print(f"\nEpoch {epoch}, Loss: {loss:.6f}")
  71.                 print("Predictions:", predictions)
  72.                 print("Binary:", [1 if p > 0.5 else 0 for p in predictions])
  73.  
  74.         return losses
  75.  
  76. # Данные
  77. X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float64)
  78. y = np.array([[1], [0], [0], [1]], dtype=np.float64)  # XNOR
  79.  
  80. # Создание и обучение сети
  81. print("Обучение XNOR нейросети...")
  82. network = TrainableXNOR(learning_rate=0.8)
  83. losses = network.train(X, y, epochs=10000)
  84.  
  85. # Финальное тестирование
  86. print("\n" + "="*50)
  87. print("Финальные результаты:")
  88. print("Input  Target  Output     Predicted")
  89. print("-"*50)
  90.  
  91. for i in range(len(X)):
  92.     output = network.forward(X[i:i+1])
  93.     predicted = 1 if output[0][0] > 0.5 else 0
  94.     status = "✓" if predicted == y[i][0] else "✗"
  95.     print(f"{X[i]}   {int(y[i][0])}      {output[0][0]:.6f}   {predicted} {status}")
  96.  
  97. # Проверка точности
  98. correct = 0
  99. for i in range(len(X)):
  100.     output = network.forward(X[i:i+1])
  101.     predicted = 1 if output[0][0] > 0.5 else 0
  102.     if predicted == y[i][0]:
  103.         correct += 1
  104.  
  105. print(f"\nТочность: {correct}/{len(X)} ({(correct/len(X))*100:.1f}%)")
Success #stdin #stdout 2.07s 42436KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Обучение XNOR нейросети...

Epoch 0, Loss: 0.268629
Predictions: [0.61521647 0.64757458 0.62071863 0.65098344]
Binary: [1, 1, 1, 1]

Epoch 2000, Loss: 0.249974
Predictions: [0.50153169 0.50817327 0.49181139 0.49869388]
Binary: [1, 1, 0, 0]

Epoch 4000, Loss: 0.248670
Predictions: [0.51964867 0.51047043 0.48709161 0.48414718]
Binary: [1, 1, 0, 0]

Epoch 6000, Loss: 0.077557
Predictions: [0.84046218 0.30756496 0.23545339 0.63292944]
Binary: [1, 0, 0, 1]

Epoch 8000, Loss: 0.006901
Predictions: [0.94409542 0.08542116 0.0858291  0.90093414]
Binary: [1, 0, 0, 1]

==================================================
Финальные результаты:
Input  Target  Output     Predicted
--------------------------------------------------
[0. 0.]   1      0.963266   1 ✓
[0. 1.]   0      0.056341   0 ✓
[1. 0.]   0      0.056822   0 ✓
[1. 1.]   1      0.935191   1 ✓

Точность: 4/4 (100.0%)
https://ideone.com/SKh3Yr
language:
Python 3 (python  3.12)
created:
1 day ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!