import random
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.table as tbl

# Функция для генерации случайной 5-значной строки из английских букв
def get_random_label():
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
return ''.join(random.choice(alphabet) for _ in range(5))

# Функция для вычисления выхода нейронной сети
def compute_neural_network(inputs, weights):
lstm = [[inputs, 0, 0] for i in range(len(inputs))]

for layer_weights in weights:
weighted_sum = sum(lstm[neuron][0] layer_weights[neuron] for neuron in range(len(inputs)))

input_gate = sigmoid(weighted_sum)
forget_gate = sigmoid(weighted_sum)
output_gate = sigmoid(weighted_sum)
memory_cell = np.tanh(weighted_sum)

for i in range(len(inputs)):
lstm[1] = lstm[1] forget_gate + input_gate memory_cell
lstm[2] = output_gate np.tanh(lstm[1])
lstm[0] = lstm[2]

return lstm[len(inputs) // 2][0]

def sigmoid(x):
return 1 / (1 + np.exp(-x))

# Главная функция для симуляции нейронных вычислений
def simulate_neural_computation():
cache = {}
cache_hits = 0
label_count = {}
results = []

num_neurons = 8
num_inputs = 8

for _ in range(5000): # Симуляция 5000 циклов
for i in range(num_neurons):
inputs = [random.randint(0, 1) for _ in range(num_inputs)]
cache_key = ','.join(map(str, inputs))

if cache_key in cache:
output, label = cache[cache_key]
cache_hits += 1
else:
weights = [[random.randint(0, 1) for _ in range(num_inputs)] for _ in range(num_inputs)]
output = compute_neural_network(inputs, weights)
label = get_random_label()
cache[cache_key] = (output, label)
label_count[label] = label_count.get(label, 0) + 1

results.append(f'Нейрон {i + 1}: Входы: {inputs}, Результат: {output}, Метка: {label}')

if len(cache) >= 5000:
break
if len(cache) >= 5000:
break

with open('results.txt', 'w') as file:
for result in results:
file.write(result + '\n')
file.write(f'Результатов в кэше: {len(cache)}, Попаданий в кеш: {cache_hits}\n')

return cache, label_count

# Визуализация результатов
def visualize_results(cache, label_count):
fig, axs = plt.subplots(2, 1, figsize=(10, 15))

# Визуализация кэша
axs[0].set_title('Кэшированные результаты')
table_data = [['Входы', 'Результат', 'Метка']]
for key, (output, label) in cache.items():
table_data.append([key, output, label])
cache_table = tbl.Table(axs[0], bbox=[0, 0, 1, 1])
axs[0].add_table(cache_table)
cache_table.auto_set_font_size(False)
cache_table.set_fontsize(10)
cache_table.scale(1, 1.5)
for i, row in enumerate(table_data):
for j, cell in enumerate(row):
cache_table.add_cell(i, j, width=1/3, height=0.05, text=cell, loc='center')

# Визуализация частых меток
axs[1].set_title('Самые частые метки')
sorted_labels = sorted(label_count.items(), key=lambda x: x[1], reverse=True)[:64]
label_table = tbl.Table(axs[1], bbox=[0, 0, 1, 1])
axs[1].add_table(label_table)
label_table.auto_set_font_size(False)
label_table.set_fontsize(10)
label_table.scale(1, 1.5)
for i in range(8):
for j in range(8):
idx = i * 8 + j
if idx < len(sorted_labels):
label, count = sorted_labels[idx]
text = f'{label} ({count})'
else:
text = ''
label_table.add_cell(i, j, width=1/8, height=0.1, text=text, loc='center')

plt.show()

# Основной запуск симуляции и визуализации
cache, label_count = simulate_neural_computation()
visualize_results(cache, label_count)