Простая нейронная сеть без библиотек и матриц. Эволюционный алгоритм

class Ball:     def __init__(self, x, y, radius):         # Инициализация экземпляра класса Ball с заданными параметрами         self.pos = Vector(x, y)  # Позиция шара как вектор         self.radius = radius  # Радиус шара         self.movement = Vector(0, 1)  # Вектор скорости шара         self.collide = False  # Флаг пересечения с границей         self.weight = 1  # Масса шара      def next_frame(self, edges):         collide = False  # Инициализация флага пересечения          normals = []  # Список для хранения нормалей к граням         intersect = []  # Список для хранения флагов пересечения         for i, edge in enumerate(edges):             normal = calculate_edge_normal(edge[0], edge[1])  # Вычисление нормали к грани             normals.append(normal)             height = (self.pos, self.pos + (normal * self.radius))  # Вычисление высоты от центра шара к грани              intersect.append(lines_intersect(edge, height))  # Определение пересечения          # Обработка пересечений с гранями         # Если две пересечения, выбирается ближайшее по расстоянию         # Производится изменение скорости и позиции шара         # Если пересечения нет, движение шара продолжается без изменений         # Скорость шара увеличивается на вектор ускорения G (гравитации)         for i in range(4):             if intersect[i] and intersect[i + 1]:                 if (intersect[i] - self.pos).length() <= (intersect[i + 1] - self.pos).length():                     self.movement = (normals[i] * self.movement.length()) * -1 * self.weight                     self.pos -= normals[i]                 else:                     self.movement = (normals[i + 1] * self.movement.length()) * -1 * self.weight                     self.pos -= normals[i + 1]              elif intersect[i]:                 self.movement = (normals[i] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[i]              elif intersect[i + 1]:                 self.movement = (normals[i + 1] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[i + 1]          self.collide = any(intersect)  # Обновление флага пересечения         self.movement += G * self.weight  # Применение гравитации к скорости         self.pos += self.movement  # Применение скорости к позиции шара   class Platform:     def __init__(self, x, y, height, width, rotate):         self.pos = Vector(x, y)         self.height = height         self.width = width         self.rotate = rotate

class RotatingRectangleApp:     def __init__(self, root):         # Инициализация приложения         self.root = root         self.root.title("Rotate Rectangle")         self.canvas = tk.Canvas(root, width=1280, height=1280)         self.canvas.pack()          # Создание экземпляров платформы и двух шаров         self.rectangle = Platform(1280//2, 1280//2, 10, 800, 0)         self.ball = Ball(1280//2-100, 1280//2 - 500, 25)         self.ball1 = Ball(1280//2+100, 1280//2 - 300, 25)                  # Создание и отображение прямоугольника на холсте         self.drawing_rectangle = self.canvas.create_rectangle(self.rectangle.pos.x, self.rectangle.pos.y, self.rectangle.width, self.rectangle.height, outline='red', fill='red', width=2)                  # Привязка клавиш к методам         self.root.bind("<Right>", self.rotate_right)         self.root.bind("<Left>", self.rotate_left)         self.root.bind("<Up>", self.set_pause)      def rotate_right(self, event):         # Метод вращения прямоугольника вправо         self.rectangle.rotate = self.rectangle.rotate + 1  # Вращение на 1 градус      def set_pause(self, event):         # Метод для приостановки/возобновления движения шаров         global pause         pause = not pause      def rotate_left(self, event):         # Метод вращения прямоугольника влево         self.rectangle.rotate = self.rectangle.rotate - 1  # Вращение на 1 градус      def draw_rectangle(self):         # Метод для отображения вращающегося прямоугольника                  # Вычисление координат углов прямоугольника после вращения         center_x = self.rectangle.pos.x         center_y = self.rectangle.pos.y         angle_rad = math.radians(self.rectangle.rotate)                  corner_coords = [             self.rotate_point(self.rectangle.pos.x - self.rectangle.width/2, self.rectangle.pos.y - self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x + self.rectangle.width/2, self.rectangle.pos.y - self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x + self.rectangle.width/2, self.rectangle.pos.y + self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x - self.rectangle.width/2, self.rectangle.pos.y + self.rectangle.height/2, center_x, center_y, angle_rad)         ]          edges = [(Vector(corner_coords[i%4][0], corner_coords[i%4][1]), Vector(corner_coords[(i+1)%4][0], corner_coords[(i+1)%4][1])) for i in range(4)]          # Создание и отображение прямоугольника на холсте         self.drawing_rectangle = self.canvas.create_polygon(corner_coords, outline='red', fill='red', width=2)         return edges      def draw_ball(self):         # Метод для отображения шаров         coords = [             (self.ball.pos.x - self.ball.radius, self.ball.pos.y - self.ball.radius),             (self.ball.pos.x + self.ball.radius, self.ball.pos.y + self.ball.radius),         ]          self.canvas.create_oval(coords, outline='black', fill='', width=2)          coords = [             (self.ball1.pos.x - self.ball1.radius, self.ball1.pos.y - self.ball1.radius),             (self.ball1.pos.x + self.ball1.radius, self.ball1.pos.y + self.ball1.radius),         ]          self.canvas.create_oval(coords, outline='black', fill='', width=2)      def rotate_point(self, x, y, cx, cy, angle_rad):         # Метод для вращения точки вокруг центра         new_x = cx + (x - cx) * math.cos(angle_rad) - (y - cy) * math.sin(angle_rad)         new_y = cy + (x - cx) * math.sin(angle_rad) + (y - cy) * math.cos(angle_rad)         return new_x, new_y      def clear_canvas(self):         # Метод для очистки холста         self.canvas.delete("all") 

# Создание начальной популяции нейронных сетей generation = [NeuralNetwork([7, 20, 20, 3]) for i in range(20)]  gen_count = 0 graph = []  # Список для хранения результатов поколений  # Бесконечный цикл эволюции и обучения while True:     gen_count += 1     generation_times = []  # Список для хранения времени выполнения для каждой сети в поколении      for i, nn in enumerate(generation):         root = tk.Tk()         app = RotatingRectangleApp(root)          # Запуск симуляции движения шара и вращения прямоугольника         start_time = datetime.datetime.now()         frames_count = -1         while 0 <= app.ball.pos.x <= 1280 and 0 <= app.ball.pos.y <= 1280:             frames_count += 1             edges = app.draw_rectangle()             app.ball.next_frame(edges)             input = [app.rectangle.rotate/360, app.rectangle.pos.x/1280, app.rectangle.pos.y/1280, app.ball.pos.x/1280, app.ball.pos.y/1280, app.ball.movement.x, app.ball.movement.y]             formatted_input = [math.tanh(el) for el in input]              # Прямой проход через нейронную сеть             out = nn.out(formatted_input)[-1]              # Обновление параметров вращения прямоугольника и движения шара на основе выхода сети             app.rectangle.rotate = (app.rectangle.rotate + out[0]) % 360             app.rectangle.pos += Vector(out[1], out[2])              app.draw_ball()             root.update()             if pause:                 time.sleep(0.01)             app.clear_canvas()                  root.destroy()         all_time = frames_count         generation_times.append(all_time)          # Эволюционный отбор: выбор наиболее успешных сетей     sorted_times = sorted(generation_times)[-4:]     lucky = [generation_times.index(el) for el in sorted_times]      if max(generation_times) >= 15000:         for el in lucky:             generation[el].save(f'dumps/{gen_count}-{el}-{generation_times[el]}.nn')      # Создание нового поколения на основе лучших сетей текущего поколения     new_generation = [copy(generation[lucky[0]]) for el in range(5)] + [copy(generation[lucky[1]]) for el in range(5)] + [copy(generation[lucky[2]]) for el in range(5)] + [copy(generation[lucky[3]]) for el in range(5)]     k_mut = 0.1     for i in range(len(new_generation)):         if i % 5 != 0:             new_generation[i].mutate(k_mut)      generation = new_generation     graph.append(max(generation_times))          # Вывод информации о текущем поколении     print(gen_count, generation_times, lucky, max(generation_times))     print(generation[0].difference(generation[1]))      # Отображение графика с результатами     plt.close()     plt.plot(graph[-100:])     plt.show(block=False)     plt.pause(0.0000001) 

import math import random import time import datetime import json from copy import copy  activation = math.tanh deactivation = math.tanh   class NeuralNetwork:     def __init__(self, neurons_size: list, weights: list = None):         self.neuron_size = neurons_size         for i in range(len(neurons_size) - 1):             self.neuron_size[i] += 1          if weights is None:             self.weights = []             for i in range(len(neurons_size) - 1):                 self.weights.append(                     [[random.uniform(-1, 1) for x in range(neurons_size[i + 1])] for y in range(neurons_size[i])])         else:             self.weights = weights      def out(self, inp):         out = [inp + [1]]         for i in range(1, len(self.weights) + 1):             a = []             for j in range(self.neuron_size[i]):                 s = sum([out[i - 1][k] * self.weights[i - 1][k][j] for k in range(self.neuron_size[i - 1])])                 a.append(activation(s))             if i != len(self.weights):                 a += [1]             out.append(a)         return out      def correct(self, inp, answer, learning_rate=0.1):         out = self.out(inp)         errors = [[answer[i] - out[-1][i] for i in range(len(out[-1]))]]          for i in range(len(self.weights) - 1, 0, -1):             a = []             for j in range(self.neuron_size[i]):                 s = sum([errors[0][k] * self.weights[i][j][k] for k in range(self.neuron_size[i + 1])])                 a.append((1 - out[i][j] ** 2) * s)             errors.insert(0, a)          for i in range(len(self.weights)):             for j in range(self.neuron_size[i]):                 for k in range(self.neuron_size[i + 1]):                     self.weights[i][j][k] += learning_rate * errors[i][k] * out[i][j]          error_count = sum([sum(abs(en) for en in el) for el in errors])         return out, error_count      def mutate(self, mutate_k):         for layer in range(len(self.weights)):             for inp in range(len(self.weights[layer])):                 for outp in range(len(self.weights[layer][inp])):                     self.weights[layer][inp][outp] += random.uniform(-mutate_k, mutate_k)      def difference(self, other):         if self.neuron_size != other.neuron_size:             return None         difference_count = 0         for layer in range(len(self.weights)):             for inp in range(len(self.weights[layer])):                 for outp in range(len(self.weights[layer][inp])):                     difference_count += abs(self.weights[layer][inp][outp] - other.weights[layer][inp][outp])          return difference_count      def save(self, name):         with open(name, 'w') as f:             neuron_size = copy(self.neuron_size)             for i in range(len(neuron_size) - 1):                 neuron_size[i] -= 1             f.write(json.dumps({'shape': neuron_size, 'weights': self.weights}))      def open(name):         with open(name, 'r') as f:             data = json.loads(f.read())             return NeuralNetwork(data['shape'], data['weights'])      def show(self, name):         import matplotlib.pyplot as plt         import networkx as nx         from networkx.drawing.nx_agraph import graphviz_layout          G = nx.DiGraph()          for layer in range(len(self.neuron_size)):             for neuron in range(self.neuron_size[layer]):                 G.add_node((layer, neuron))          for layer in range(len(self.neuron_size) - 1):             for from_neuron in range(self.neuron_size[layer]):                 for to_neuron in range(self.neuron_size[layer + 1]):                     weight = self.weights[layer][from_neuron][to_neuron]                     G.add_edge((layer, from_neuron), (layer + 1, to_neuron), weight=weight)          pos = graphviz_layout(G, prog='dot', args="-Grankdir=LR")          edge_widths = [2 + abs(G.edges[edge]['weight']) for edge in G.edges]         edge_alpha = [abs(activation(G.edges[edge]['weight'])) / 2 for edge in G.edges]         edge_colors = ['green' if G.edges[edge]['weight'] >= 0 else 'red' for edge in G.edges]          nx.draw_networkx_nodes(G, pos, node_size=300, node_color='skyblue', alpha=0.8)          nx.draw_networkx_edges(G, pos, width=edge_widths, alpha=edge_alpha, edge_color=edge_colors, arrows=True)          layer_labels = {}         for layer in range(len(self.neuron_size)):             for neuron in range(self.neuron_size[layer]):                 layer_labels[(layer, neuron)] = f"{neuron}"         nx.draw_networkx_labels(G, pos, labels=layer_labels, font_size=12, font_color='r')          plt.axis('off')         plt.title(f"Neural Network Weights")         plt.savefig(f'{name}.png') 

import random import time import tkinter as tk import math from copy import deepcopy as copy from neuro import NeuralNetwork import datetime import matplotlib.pyplot as plt   class Vector:     def __init__(self, x, y):         self.x = x         self.y = y      def __add__(self, other):         new = Vector(self.x + other.x, self.y + other.y)         return new      def __mul__(self, other):         new = Vector(self.x * other, self.y * other)         return new      def __sub__(self, other):         new = Vector(self.x - other.x, self.y - other.y)         return new      def length(self):         return (self.x**2 + self.y**2) ** 0.5   def calculate_edge_normal(point1, point2):  # Функция для вычисления нормали к ребру     edge_vector = Vector(point2.x - point1.x, point2.y - point1.y)  # Вычисление вектора ребра     edge_length = edge_vector.length()  # Вычисление длины ребра      if edge_length == 0:         raise ValueError("The edge has zero length.")  # Исключение, если длина ребра равна нулю      normalized_edge_vector = Vector(edge_vector.x / edge_length,                                     edge_vector.y / edge_length)  # Нормализация вектора ребра     normal_vector = Vector(-normalized_edge_vector.y, normalized_edge_vector.x)  # Создание вектора нормали     return normal_vector  # Возврат вычисленной нормали к ребру   def lines_intersect(line1, line2):     x1, y1, x2, y2 = line1[0].x, line1[0].y, line1[1].x, line1[1].y     x3, y3, x4, y4 = line2[0].x, line2[0].y, line2[1].x, line2[1].y      slope1 = (y2 - y1) / (x2 - x1) if x2 - x1 != 0 else float('inf')     slope2 = (y4 - y3) / (x4 - x3) if x4 - x3 != 0 else float('inf')      if slope1 == slope2:         return False      if slope1 == float('inf'):         x = x1         y = slope2 * (x - x3) + y3     elif slope2 == float('inf'):         x = x3         y = slope1 * (x - x1) + y1     else:         x = (slope1 * x1 - slope2 * x3 + y3 - y1) / (slope1 - slope2)         y = slope1 * (x - x1) + y1      if ((x1 <= x <= x2 or x2 <= x <= x1) and         (x3 <= x <= x4 or x4 <= x <= x3)) and              ((y1 <= y <= y2 or y2 <= y <= y1) and              (y3 <= y <= y4 or y4 <= y <= y3)):         return True      return False   G = Vector(0, .1)   class Ball:     def __init__(self, x, y, radius):         self.pos = Vector(x, y)         self.radius = radius         self.movement = Vector(0, 1)         self.collide = False         self.weight = 1      def next_frame(self, edges):         collide = False          normals = []         intersect = []         for i, edge in enumerate(edges):             normal = calculate_edge_normal(edge[0], edge[1])             normals.append(normal)             height = (self.pos, self.pos + (normal * self.radius))              intersect.append(lines_intersect(edge, height))          if intersect[0] and intersect[1]:             if (intersect[0] - self.pos).length() <= (intersect[1] - self.pos).length():                 self.movement = (normals[0] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[0]             else:                 self.movement = (normals[1] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[1]          elif intersect[0]:             self.movement = (normals[0] * self.movement.length()) * -1 * self.weight             self.pos -= normals[0]          elif intersect[1]:             self.movement = (normals[1] * self.movement.length()) * -1 * self.weight             self.pos -= normals[1]          if intersect[2] and intersect[3]:             if (intersect[2] - self.pos).length() <= (intersect[3] - self.pos).length():                 self.movement = (normals[2] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[2]             else:                 self.movement = (normals[3] * self.movement.length()) * -1 * self.weight                 self.pos -= normals[3]          elif intersect[2]:             self.movement = (normals[2] * self.movement.length()) * -1 * self.weight             self.pos -= normals[2]          elif intersect[3]:             self.movement = (normals[3] * self.movement.length()) * -1 * self.weight             self.pos -= normals[3]          self.collide = any(intersect)         self.movement += G*self.weight         self.pos += self.movement   pause = False   class Platform:     def __init__(self, x, y, height, width, rotate):         self.pos = Vector(x, y)         self.height = height         self.width = width         self.rotate = rotate   class RotatingRectangleApp:     def __init__(self, root):         self.root = root         self.root.title("Rotate Rectangle")          self.canvas = tk.Canvas(root, width=1280, height=1280)         self.canvas.pack()          self.rectangle = Platform(1280//2, 1280//2, 10, 800, 0)         self.ball = Ball(1280//2-100, 1280//2 - 500, 25)         self.drawing_rectangle = self.canvas.create_rectangle(self.rectangle.pos.x, self.rectangle.pos.y, self.rectangle.width, self.rectangle.height, outline='red', fill='red', width=2)         self.root.bind("<Right>", self.rotate_right)  # Bind right arrow key         self.root.bind("<Left>", self.rotate_left)         self.root.bind("<Up>", self.set_pause)      def rotate_right(self, event):         self.rectangle.rotate = self.rectangle.rotate + 1  # Rotate by 15 degrees each time      def set_pause(self, event):         global pause         pause = not pause      def rotate_left(self, event):         self.rectangle.rotate = self.rectangle.rotate - 1  # Rotate by 15 degrees each time      def draw_rectangle(self):         center_x = self.rectangle.pos.x         center_y = self.rectangle.pos.y          angle_rad = math.radians(self.rectangle.rotate)          corner_coords = [             self.rotate_point(self.rectangle.pos.x - self.rectangle.width/2, self.rectangle.pos.y - self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x + self.rectangle.width/2, self.rectangle.pos.y - self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x + self.rectangle.width/2, self.rectangle.pos.y + self.rectangle.height/2, center_x, center_y, angle_rad),             self.rotate_point(self.rectangle.pos.x - self.rectangle.width/2, self.rectangle.pos.y + self.rectangle.height/2, center_x, center_y, angle_rad)         ]          edges = [(Vector(corner_coords[i%4][0], corner_coords[i%4][1]), Vector(corner_coords[(i+1)%4][0], corner_coords[(i+1)%4][1])) for i in range(4)]          self.drawing_rectangle = self.canvas.create_polygon(corner_coords, outline='red', fill='red', width=2)         return edges      def draw_ball(self):         coords = [             (self.ball.pos.x - self.ball.radius, self.ball.pos.y - self.ball.radius),             (self.ball.pos.x + self.ball.radius, self.ball.pos.y + self.ball.radius),         ]          self.canvas.create_oval(coords, outline='black', fill='', width=2)      def rotate_point(self, x, y, cx, cy, angle_rad):         new_x = cx + (x - cx) * math.cos(angle_rad) - (y - cy) * math.sin(angle_rad)         new_y = cy + (x - cx) * math.sin(angle_rad) + (y - cy) * math.cos(angle_rad)         return new_x, new_y      def clear_canvas(self):         self.canvas.delete("all")   if __name__ == "__main__":     graph = []     generation = [NeuralNetwork([7, 20, 20, 3]) for i in range(20)]     gen_count = 0     while True:         gen_count += 1         generation_times = []         for i, nn in enumerate(generation):             root = tk.Tk()              app = RotatingRectangleApp(root)             start_time = datetime.datetime.now()             frames_count = -1             while 0 <= app.ball.pos.x <= 1280 and 0 <= app.ball.pos.y <= 1280:                 frames_count += 1                 #app.rectangle.rotate = math.cos(app.rectangle.rotate)*360                 edges = app.draw_rectangle()                 app.ball.next_frame(edges)                 input = [app.rectangle.rotate/360, app.rectangle.pos.x/1280, app.rectangle.pos.y/1280, app.ball.pos.x/1280, app.ball.pos.y/1280, app.ball.movement.x, app.ball.movement.y]                 formatted_input = [math.tanh(el) for el in input]                 out = nn.out(formatted_input)[-1]                 app.rectangle.rotate = (app.rectangle.rotate + out[0]) % 360                 app.rectangle.pos += Vector(out[1], out[2])                 #if gen_count % 100 == 0 or frames_count >= 20000:                 app.draw_ball()                 root.update()                 if pause:                     time.sleep(0.01)                 app.clear_canvas()             root.destroy()             all_time = frames_count             generation_times.append(all_time)          root.mainloop()         sorted_times = sorted(generation_times)[-4:]         lucky = [generation_times.index(el) for el in sorted_times]          if max(generation_times) >= 15000:             for el in lucky:                 generation[el].save(f'dumps/{gen_count}-{el}-{generation_times[el]}.nn')          new_generation = [copy(generation[lucky[0]]) for el in range(5)] + [copy(generation[lucky[1]]) for el in range(5)] + [copy(generation[lucky[2]]) for el in range(5)] + [copy(generation[lucky[3]]) for el in range(5)]         k_mut = 0.1         for i in range(len(new_generation)):             if i % 5 != 0:                 new_generation[i].mutate(k_mut)          generation = new_generation         graph.append(max(generation_times))         print(gen_count, generation_times, lucky, max(generation_times))         print(generation[0].difference(generation[1]))         plt.close()         plt.plot(graph[-100:])         plt.show(block=False)         plt.pause(0.0000001)