Upload liberal_mind_beta (1).py

liberal_mind_beta (1).py

@@ -0,0 +1,1796 @@
+# -*- coding: utf-8 -*-
+"""liberal mind beta
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1WZLrb1Gf63n6vXBvGFEWwIPt1BU_5xc9
+
+# ***INSTALL LIBRARIES***
+"""
+
+pip install stable_baselines3
+
+pip install datasets
+
+pip install torch-geometric
+
+pip install gym==0.21.0
+
+pip install shimmy
+
+"""# ***DOWNLOAD DATASETS***"""
+
+from datasets import load_dataset
+from huggingface_hub import list_datasets
+
+def find_and_load_dataset(keyword):
+    # Ищем датасеты по ключевому слову
+    matching_datasets = [ds.id for ds in list_datasets() if keyword.lower() in ds.id.lower()]
+
+    # Проверяем, найдены ли соответствующие датасеты
+    if not matching_datasets:
+        print("Нет датасетов, содержащих указанное ключевое слово.")
+        return None
+
+    # Выбираем первый найденный датасет
+    dataset_name = matching_datasets[0]
+    print(f"Найден датасет: {dataset_name}. Загружаем его...")
+
+    # Загружаем датасет
+    dataset = load_dataset(dataset_name)
+    return dataset
+
+# Пример использования
+keyword = input("Введите ключевое слово для поиска датасета: ")
+dataset = find_and_load_dataset(keyword)
+
+if dataset:
+    print("Датасет загружен успешно!")
+    print(dataset)
+
+import os
+import shutil
+from datasets import load_dataset
+
+# Имя и путь для сохранения
+dataset_name = "Unified-Language-Model-Alignment/Anthropic_HH_Golden"  # Замените на точное имя датасета
+save_dir = "/content/dataset"  # Путь для сохранения в директории Google Colab
+
+# Загружаем датасет
+dataset = load_dataset(dataset_name)
+
+# Убеждаемся, что папка для сохранения существует
+os.makedirs(save_dir, exist_ok=True)
+
+# Копируем файлы датасета из кэша в нужную директорию
+for split_cache_files in dataset.cache_files.values():
+    for cache_file in split_cache_files:
+        shutil.copy2(cache_file['filename'], save_dir)
+
+print(f"Датасет '{dataset_name}' сохранен в папке {save_dir}")
+
+"""# ***ENCODER TRANSFORMERS MATH AI***"""
+
+import numpy as np
+import tensorflow as tf
+import torch
+from torch import nn, optim
+from sklearn.ensemble import RandomForestClassifier
+from scipy.cluster.hierarchy import linkage, fcluster
+from sklearn.preprocessing import StandardScaler
+from stable_baselines3 import PPO
+
+import numpy as np
+import torch
+import torch.nn as nn
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Discrete, Box
+
+# Оптимизированные гиперпараметры для многоязыковой LLM
+ppo_hyperparameters = {
+    "n_steps": 1024,                # Увеличение шагов для лучшего захвата зависимости данных
+    "batch_size": 64,               # Оптимальный размер для стабилизации обучения
+    "n_epochs": 1,                 # Баланс скорости обновления и обучения
+    "gamma": 0.99,                  # Стандартное значение дисконтирования
+    "learning_rate": 3e-4,          # Стандартный темп обучения
+    "clip_range": 0.2,              # Оптимальное значение для стабильности
+    "gae_lambda": 0.95,             # Гладкость обобщенного преимущества
+    "vf_coef": 0.5,                 # Коэффициент функции ценности
+    "ent_coef": 0.01,               # Коэффициент энтропии для исследования
+    "max_grad_norm": 0.5,           # Ограничение градиента
+    "target_kl": 0.03,              # Целевое значение KL-дивергенции
+    "penalty_coef": 0.05,           # Регуляция для устойчивости
+    "epsilon": 0.15,                # Умеренная случайность
+    "adv_norm": True,               # Нормализация преимущества
+    "weight_init": "xavier"         # Инициализация весов
+}
+
+
+class ComplexEnv(Env):
+    def __init__(self):
+        super(ComplexEnv, self).__init__()
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=-10, high=10, shape=(5,), dtype=np.float32)
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+
+    def reset(self):
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+        return self.state
+
+    def step(self, action):
+        reward = -0.1
+        self.step_count += 1
+
+        if action == 0:
+            reward += 1 if self.state[0] > 0 else -1 * ppo_hyperparameters["penalty_coef"]
+        elif action == 1:
+            reward += 0.5 if np.sum(self.state) > 0 else -2 * ppo_hyperparameters["penalty_coef"]
+        else:
+            reward += -0.5 if self.state[1] < 0 else 1 * ppo_hyperparameters["penalty_coef"]
+
+        self.state += np.random.normal(0, 0.5, size=self.state.shape)
+
+        done = self.step_count >= 100
+        return self.state, reward, done, {}
+
+# Инициализация среды
+env = ComplexEnv()
+
+# Определение и настройка модели PPO с новыми гиперпараметрами и инициализацией весов
+class EpsilonPPO(PPO):
+    def __init__(self, policy, env, **kwargs):
+        super(EpsilonPPO, self).__init__(policy, env, **kwargs)
+        self.epsilon = ppo_hyperparameters["epsilon"]
+
+        # Инициализация весов
+        for layer in self.policy.modules():
+            if isinstance(layer, (nn.Linear, nn.Conv2d)):
+                if ppo_hyperparameters["weight_init"] == "xavier":
+                    nn.init.xavier_uniform_(layer.weight)
+                elif ppo_hyperparameters["weight_init"] == "kaiming":
+                    nn.init.kaiming_uniform_(layer.weight)
+
+    def _predict(self, observation, deterministic=False):
+        if np.random.rand() < self.epsilon:
+            return self.env.action_space.sample()
+        else:
+            return super().predict(observation, deterministic=deterministic)
+
+# Создание PPO модели с новыми гиперпараметрами и нормализацией
+model = EpsilonPPO(
+    policy="MlpPolicy",
+    env=env,
+    verbose=1,
+    n_steps=ppo_hyperparameters["n_steps"],
+    batch_size=ppo_hyperparameters["batch_size"],
+    n_epochs=ppo_hyperparameters["n_epochs"],
+    gamma=ppo_hyperparameters["gamma"],
+    learning_rate=ppo_hyperparameters["learning_rate"],
+    clip_range=ppo_hyperparameters["clip_range"],
+    gae_lambda=ppo_hyperparameters["gae_lambda"],
+    vf_coef=ppo_hyperparameters["vf_coef"],
+    ent_coef=ppo_hyperparameters["ent_coef"],
+    max_grad_norm=ppo_hyperparameters["max_grad_norm"],
+    target_kl=ppo_hyperparameters["target_kl"]
+)
+
+# Обучение модели
+model.learn(total_timesteps=50000)
+
+# Проверка работы агента
+obs = env.reset()
+for _ in range(100):
+    action, _ = model.predict(obs)
+    obs, reward, done, _ = env.step(action)
+    if done:
+        obs = env.reset()
+
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.cluster import AgglomerativeClustering
+from scipy.spatial.distance import euclidean
+from sklearn.preprocessing import StandardScaler
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Discrete, Box
+
+# Настройка Random Forest
+def classify_data(X, y):
+    rf = RandomForestClassifier(n_estimators=100)
+    rf.fit(X, y)
+    feature_importances = rf.feature_importances_
+    return feature_importances, rf
+
+# Иерархическая кластеризация
+def cluster_data(X):
+    clustering = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
+    clusters = clustering.fit_predict(X)
+    return clusters
+
+class LSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(LSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        _, (hn, _) = self.lstm(x)  # передаём через LSTM
+        out = self.fc(hn[-1])  # последний скрытый слой
+        return out
+
+# Параметры LSTM
+input_size = 5
+hidden_size = 32
+output_size = 3
+lstm_agent = LSTMModel(input_size, hidden_size, output_size)
+
+class ComplexEnvWithLSTM(Env):
+    def __init__(self):
+        super(ComplexEnvWithLSTM, self).__init__()
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=-10, high=10, shape=(5,), dtype=np.float32)
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+
+    def reset(self):
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+        return self.state
+
+    def step(self, action):
+        reward = -0.1
+        self.step_count += 1
+
+        # Логика наград
+        if action == 0:
+            reward += 1 if self.state[0] > 0 else -0.5
+        elif action == 1:
+            reward += 0.5 if np.sum(self.state) > 0 else -1
+        else:
+            reward += -0.5 if self.state[1] < 0 else 1
+
+        # Обновляем состояние с учетом LSTM
+        self.state += np.random.normal(0, 0.5, size=self.state.shape)
+
+        done = self.step_count >= 100
+        return self.state, reward, done, {}
+
+env = ComplexEnvWithLSTM()
+
+def classify_data(X, y):
+    rf = RandomForestClassifier(n_estimators=100)
+    rf.fit(X, y)
+    feature_importances = rf.feature_importances_
+    return feature_importances, rf
+
+def cluster_data(X):
+    clustering = AgglomerativeClustering(n_clusters=5, metric='euclidean', linkage='ward')
+    clusters = clustering.fit_predict(X)
+    return clusters
+class AdvancedLSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=2, dropout=0.3, use_sigmoid=True):
+        super(AdvancedLSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+
+        # Полносвязные слои
+        self.fc1 = nn.Linear(hidden_size, 1000)
+        self.fc2 = nn.Linear(1000, 2000)
+        self.activation = nn.Sigmoid() if use_sigmoid else nn.ReLU()
+
+    def forward(self, x):
+        _, (hn, _) = self.lstm(x)
+        x = self.fc1(hn[-1])
+        x = self.activation(x)
+        x = self.fc2(x)
+        return x
+
+# Параметры LSTM
+input_size = 5
+hidden_size = 256
+output_size = 2000
+num_layers = 3
+dropout = 0.3
+use_sigmoid = True
+lstm_agent = AdvancedLSTMModel(input_size, hidden_size, output_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+class ComplexEnvWithLSTM(Env):
+    def __init__(self):
+        super(ComplexEnvWithLSTM, self).__init__()
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=-10, high=10, shape=(5,), dtype=np.float32)
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+
+    def reset(self):
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+        return self.state
+
+    def step(self, action):
+        reward = -0.1
+        self.step_count += 1
+
+        if action == 0:
+            reward += 1 if self.state[0] > 0 else -0.5
+        elif action == 1:
+            reward += 0.5 if np.sum(self.state) > 0 else -1
+        else:
+            reward += -0.5 if self.state[1] < 0 else 1
+
+        # Обновляем состояние
+        self.state += np.random.normal(0, 0.5, size=self.state.shape)
+
+        done = self.step_count >= 100
+        return self.state, reward, done, {}
+
+env = ComplexEnvWithLSTM()
+
+# Генерация данных для Random Forest и кластеризации
+X = np.random.rand(100, 5)  # Замените на реальные данные
+y = np.random.randint(0, 2, size=100)
+feature_importances, rf = classify_data(X, y)
+clusters = cluster_data(X)
+
+# Настройка PPO с LSTM
+model = PPO(
+    policy="MlpPolicy",
+    env=env,
+    verbose=1,
+    learning_rate=5e-4,
+    n_steps=512,
+    batch_size=32,
+    n_epochs=4,
+    gamma=0.99,
+    clip_range=0.2,
+    gae_lambda=0.95,
+    vf_coef=0.5,
+    ent_coef=0.005,
+    max_grad_norm=0.5,
+    target_kl=0.03,
+)
+
+# Обучение PPO с использованием LSTM
+model.learn(total_timesteps=20000)
+
+# Проверка работы агента
+obs = env.reset()
+obs = torch.tensor(obs, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+for _ in range(100):
+    action_probs = lstm_agent(obs)
+    action = action_probs.argmax().item()
+    obs, reward, done, _ = env.step(action)
+    obs = torch.tensor(obs, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+    if done:
+        obs = env.reset()
+
+"""# ***DECODER TRANSFORMERS MATH AI***"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.linear_model import LinearRegression
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Discrete, Box
+
+# Функция множественной линейной регрессии
+def distribute_outputs(X, y):
+    lin_reg = LinearRegression()
+    lin_reg.fit(X, y)
+    distributed_outputs = lin_reg.predict(X)
+    return distributed_outputs
+
+class LSTMDecoderModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=2, dropout=0.3, use_sigmoid=True):
+        super(LSTMDecoderModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+
+        # Полносвязные слои
+        self.fc1 = nn.Linear(hidden_size, 1000)
+        self.fc2 = nn.Linear(1000, 2000)
+        self.activation = nn.Sigmoid() if use_sigmoid else nn.ReLU()
+
+    def forward(self, x):
+        _, (hn, _) = self.lstm(x)
+        x = self.fc1(hn[-1])
+        x = self.activation(x)
+        x = self.fc2(x)
+        return x
+
+# Параметры модели
+input_size = 5
+hidden_size = 256
+output_size = 2000
+num_layers = 3
+dropout = 0.3
+use_sigmoid = True
+lstm_decoder = LSTMDecoderModel(input_size, hidden_size, output_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+
+class ComplexEnvForDecoder(Env):
+    def __init__(self):
+        super(ComplexEnvForDecoder, self).__init__()
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=-10, high=10, shape=(5,), dtype=np.float32)
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+
+    def reset(self):
+        self.state = np.random.uniform(low=-1, high=1, size=(5,))
+        self.step_count = 0
+        return self.state
+
+    def step(self, action):
+        reward = -0.1
+        self.step_count += 1
+
+        if action == 0:
+            reward += 1 if self.state[0] > 0 else -0.5
+        elif action == 1:
+            reward += 0.5 if np.sum(self.state) > 0 else -1
+        else:
+            reward += -0.5 if self.state[1] < 0 else 1
+
+        self.state += np.random.normal(0, 0.5, size=self.state.shape)
+        done = self.step_count >= 100
+        return self.state, reward, done, {}
+
+env_decoder = ComplexEnvForDecoder()
+
+# Генерация данных
+X = np.random.rand(100, 5)  # Замените на реальные данные
+y = np.random.randint(0, 2, size=100)
+distributed_outputs = distribute_outputs(X, y)
+
+# Настройка PPO с LSTM-декодером
+model_decoder = PPO(
+    policy="MlpPolicy",
+    env=env_decoder,
+    verbose=1,
+    learning_rate=5e-4,
+    n_steps=512,
+    batch_size=32,
+    n_epochs=4,
+    gamma=0.99,
+    clip_range=0.2,
+    gae_lambda=0.95,
+    vf_coef=0.5,
+    ent_coef=0.005,
+    max_grad_norm=0.5,
+    target_kl=0.03,
+)
+
+# Обучение PPO с использованием LSTM-декодера
+model_decoder.learn(total_timesteps=20000)
+
+# Проверка работы декодера
+obs = env_decoder.reset()
+obs = torch.tensor(obs, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+for _ in range(100):
+    action_probs = lstm_decoder(obs)
+    action = action_probs.argmax().item()
+    obs, reward, done, _ = env_decoder.step(action)
+    obs = torch.tensor(obs, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+    if done:
+        obs = env_decoder.reset()
+
+"""# ***TRANSFORMERS MATH AI***"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.cluster import AgglomerativeClustering
+from sklearn.linear_model import LinearRegression
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Discrete, Box
+
+class EncoderLSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=2, dropout=0.3, use_sigmoid=True):
+        super(EncoderLSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+        self.fc1 = nn.Linear(hidden_size, output_size)
+        self.activation = nn.Sigmoid() if use_sigmoid else nn.ReLU()
+
+    def forward(self, x):
+        _, (hn, _) = self.lstm(x)
+        x = self.fc1(hn[-1])
+        return self.activation(x)
+
+class DecoderLSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=2, dropout=0.3, use_sigmoid=True):
+        super(DecoderLSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+        self.fc1 = nn.Linear(hidden_size, output_size)
+        self.activation = nn.Sigmoid() if use_sigmoid else nn.ReLU()
+
+    def forward(self, x):
+        _, (hn, _) = self.lstm(x)
+        x = self.fc1(hn[-1])
+        return self.activation(x)
+
+class TransformerModule(nn.Module):
+    def __init__(self, input_size, hidden_size, num_heads=2, num_layers=2):
+        super(TransformerModule, self).__init__()
+        self.transformer_layer = nn.Transformer(d_model=input_size, nhead=num_heads, num_encoder_layers=num_layers, num_decoder_layers=num_layers)
+        self.fc = nn.Linear(input_size, hidden_size)
+
+    def forward(self, src, tgt):
+        # Проходим через трансформер
+        output = self.transformer_layer(src, tgt)
+        # Преобразуем выход трансформера для передачи в декодер
+        return self.fc(output)
+
+# Параметры для модели
+input_size = 32  # Сделаем input_size кратным num_heads
+hidden_size = 256
+output_size = 2000
+num_heads = 4    # Убедимся, что input_size % num_heads == 0
+num_layers = 2
+dropout = 0.3
+use_sigmoid = True
+
+# Инициализация компонентов
+encoder = EncoderLSTMModel(input_size, hidden_size, output_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+decoder = DecoderLSTMModel(input_size, hidden_size, output_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+transformer = TransformerModule(input_size, hidden_size, num_heads=num_heads, num_layers=num_layers)
+
+import torch
+import torch.nn as nn
+
+# Энкодер на основе LSTM
+class EncoderLSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers=1, dropout=0.0, use_sigmoid=False):
+        super(EncoderLSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+        self.fc = nn.Linear(hidden_size, input_size)  # Сохраняем выходной размер равным input_size
+        self.use_sigmoid = use_sigmoid
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        output = self.fc(lstm_out[:, -1, :])  # Используем только последний выход LSTM
+        if self.use_sigmoid:
+            output = torch.sigmoid(output)
+        return output
+
+# Декодер на основе LSTM
+class DecoderLSTMModel(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers=1, dropout=0.0, use_sigmoid=False):
+        super(DecoderLSTMModel, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+        self.fc = nn.Linear(hidden_size, input_size)  # Сохраняем выходной размер равным input_size
+        self.use_sigmoid = use_sigmoid
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        output = self.fc(lstm_out[:, -1, :])  # Используем только последний выход LSTM
+        if self.use_sigmoid:
+            output = torch.sigmoid(output)
+        return output
+
+# Трансформер
+class TransformerModule(nn.Module):
+    def __init__(self, input_size, num_heads=4, num_layers=2):
+        super(TransformerModule, self).__init__()
+        self.transformer_layer = nn.Transformer(
+            d_model=input_size,  # Убедитесь, что это соответствует размерности входа
+            nhead=num_heads,
+            num_encoder_layers=num_layers,
+            num_decoder_layers=num_layers
+        )
+        self.fc = nn.Linear(input_size, input_size)  # Для преобразования выходных данных
+
+    def forward(self, src, tgt):
+        # Проверка размерности входных данных
+        print(f"src shape before transformer: {src.shape}")
+        print(f"tgt shape before transformer: {tgt.shape}")
+
+        # Проходим через трансформер
+        output = self.transformer_layer(src, tgt)
+
+        # Преобразуем выход трансформера для передачи в декодер
+        return self.fc(output)
+
+# Объединённая модель
+class CombinedModel(nn.Module):
+    def __init__(self, encoder, decoder, transformer):
+        super(CombinedModel, self).__init__()
+        self.encoder = encoder
+        self.decoder = decoder
+        self.transformer = transformer
+
+    def forward(self, x):
+        # Пропускаем через энкодер
+        encoded = self.encoder(x)
+
+        # Подготавливаем входы и выходы для трансформера
+        src = encoded.unsqueeze(1)  # Изменяем размерность: (batch_size, 1, input_size)
+        tgt = torch.zeros_like(src)  # Создаём нулевую целевую последовательность
+
+        # Убедимся, что размеры правильные
+        print(f"CombinedModel: src shape: {src.shape}, tgt shape: {tgt.shape}")
+
+        # Пропускаем через трансформер
+        transformed = self.transformer(src, tgt)
+
+        # Передаём в декодер
+        output = self.decoder(transformed)
+        return output
+
+# Параметры для модели
+input_size = 32  # Размерность входа
+hidden_size = 256  # Размерность скрытого слоя
+num_heads = 4  # Количество голов
+num_layers = 2  # Количество слоёв
+dropout = 0.3  # Дропаут
+use_sigmoid = True  # Использование сигмоиды
+
+# Инициализация компонентов
+encoder = EncoderLSTMModel(input_size, hidden_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+decoder = DecoderLSTMModel(input_size, hidden_size, num_layers=num_layers, dropout=dropout, use_sigmoid=use_sigmoid)
+transformer = TransformerModule(input_size, num_heads=num_heads, num_layers=num_layers)
+
+# Создание объединённой модели
+combined_model = CombinedModel(encoder, decoder, transformer)
+
+# Пример данных
+batch_size = 10
+seq_length = 5
+example_input = torch.randn((batch_size, seq_length, input_size))  # Генерация случайного входа
+output = combined_model(example_input)
+
+print("Output shape:", output.shape)  # Вывод формы результата
+
+"""# ***CREATION AI***"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from tqdm import tqdm
+
+# Параметры диффузии и обучения
+num_steps = 1000  # Количество шагов диффузии
+input_dim = 784   # Например, для изобр��жений 28x28 = 784
+batch_size = 64   # Размер батча
+learning_rate = 1e-4
+
+# Параметры альфа
+beta_start = 1e-4
+beta_end = 0.02
+beta = np.linspace(beta_start, beta_end, num_steps)
+alpha = 1 - beta
+alpha_cumprod = np.cumprod(alpha)
+
+# Гиперпараметры модели
+class DiffusionModel(nn.Module):
+    def init(
+        self, input_dim, hidden_dim=512, output_dim=784,
+        num_layers=3, activation_function="ReLU", batch_norm=False, layer_norm=False,
+        use_skip_connections=True, dropout_rate=0.1, use_time_embedding=True,
+        time_embedding_dim=16, noise_scaling_factor=0.1, optimizer="adam",
+        learning_rate=1e-4, weight_decay=1e-5, gradient_clip_value=5.0,
+        scheduler_step_size=50, scheduler_gamma=0.95, beta_schedule="linear",
+        noise_type="gaussian", noise_seed=None, min_noise_std=0.1, max_noise_std=1.0,
+        use_positional_encoding=False, positional_encoding_scale=1.0,
+        max_training_epochs=100, min_learning_rate=1e-6, warmup_steps=500
+    ):
+        super(DiffusionModel, self).init()
+
+        # Основные гиперпараметры
+        self.use_skip_connections = use_skip_connections
+        self.use_time_embedding = use_time_embedding
+        self.noise_scaling_factor = noise_scaling_factor
+        self.time_embedding_dim = time_embedding_dim
+        self.noise_type = noise_type
+        self.min_noise_std = min_noise_std
+        self.max_noise_std = max_noise_std
+        self.noise_seed = noise_seed
+        self.use_positional_encoding = use_positional_encoding
+        self.positional_encoding_scale = positional_encoding_scale
+
+        # Инициализация архитектуры сети
+        layers = []
+        in_dim = input_dim + (self.time_embedding_dim if use_time_embedding else 0)
+
+        for _ in range(num_layers):
+            layers.append(nn.Linear(in_dim, hidden_dim))
+
+            if batch_norm:
+                layers.append(nn.BatchNorm1d(hidden_dim))
+            elif layer_norm:
+                layers.append(nn.LayerNorm(hidden_dim))
+
+            if activation_function.lower() == "relu":
+                layers.append(nn.ReLU())
+            elif activation_function.lower() == "leakyrelu":
+                layers.append(nn.LeakyReLU())
+            elif activation_function.lower() == "tanh":
+                layers.append(nn.Tanh())
+
+            if dropout_rate > 0:
+                layers.append(nn.Dropout(dropout_rate))
+
+            in_dim = hidden_dim
+
+        layers.append(nn.Linear(hidden_dim, output_dim))
+        self.network = nn.Sequential(*layers)
+
+    def forward(self, x, t):
+        if self.use_time_embedding:
+            t_embedding = torch.sin(t.float() * 2 * np.pi / num_steps).unsqueeze(-1)
+            t_embedding = t_embedding * self.time_embedding_dim
+            x = torch.cat([x, t_embedding], dim=1)
+
+        return self.network(x)
+
+
+# Функция добавления шума
+def add_noise(x, t, noise_type="gaussian", min_noise_std=0.1, max_noise_std=1.0,
+              noise_seed=None, noise_scaling_factor=0.1, beta_schedule="linear"):
+
+    if noise_seed is not None:
+        torch.manual_seed(noise_seed)
+
+    noise_std = min_noise_std + t * (max_noise_std - min_noise_std) / num_steps
+    noise = torch.randn_like(x) * noise_std if noise_type == "gaussian" else torch.rand_like(x) * noise_std
+
+    if beta_schedule == "linear":
+        alpha_t = alpha_cumprod[t].view(-1, 1)
+    elif beta_schedule == "cosine":
+        alpha_t = torch.cos(t * np.pi / num_steps).view(-1, 1)
+
+    noisy_x = torch.sqrt(alpha_t) * x + torch.sqrt(1 - alpha_t) * noise * noise_scaling_factor
+    return noisy_x
+
+"""# ***DIFFUSION TRANSFORMERS***"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from tqdm import tqdm
+
+# Параметры
+num_steps = 1000  # Количество шагов диффузии
+input_dim = 784   # Например, для изображений 28x28 = 784
+batch_size = 64   # Размер батча
+learning_rate = 1e-4
+
+# Параметры альфа
+beta_start = 1e-4
+beta_end = 0.02
+beta = np.linspace(beta_start, beta_end, num_steps)
+alpha = 1 - beta
+alpha_cumprod = np.cumprod(alpha)
+
+# Преобразование alpha_cumprod в тензор PyTorch
+alpha_cumprod_tensor = torch.tensor(alpha_cumprod, dtype=torch.float32)
+
+# Определение диффузионного энкодера
+class DiffusionEncoder(nn.Module):
+    def __init__(self):
+        super(DiffusionEncoder, self).__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_dim + 1, 512),  # Добавляем 1 для временной переменной
+            nn.ReLU(),
+            nn.Linear(512, 512),
+            nn.ReLU(),
+            nn.Linear(512, input_dim)  # Выходной размер должен соответствовать input_dim
+        )
+
+    def forward(self, x, t):
+        t_embedding = torch.sin(t.float() * 2 * np.pi / num_steps).unsqueeze(-1)  # Временная переменная
+        x = torch.cat([x, t_embedding], dim=1)  # Объединяем x и t_embedding
+        return self.network(x)
+
+# Определение декодера (полносвязная нейросеть)
+class FullyConnectedDecoder(nn.Module):
+    def __init__(self):
+        super(FullyConnectedDecoder, self).__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(),
+            nn.Linear(512, 512),
+            nn.ReLU(),
+            nn.Linear(512, input_dim)
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+# Функция добавления шума
+def add_noise(x, t):
+    noise = torch.randn_like(x)
+    alpha_t = alpha_cumprod_tensor[t].view(-1, 1)  # Индексация тензора alpha_cumprod_tensor
+    noisy_x = torch.sqrt(alpha_t) * x + torch.sqrt(1 - alpha_t) * noise
+    return noisy_x, noise
+
+# Инициализация модели и оптимизатора
+encoder = DiffusionEncoder()
+decoder = FullyConnectedDecoder()
+optimizer = optim.Adam(list(encoder.parameters()) + list(decoder.parameters()), lr=learning_rate)
+
+# Обучение модели
+for epoch in range(2):  # 100 эпох
+    for _ in tqdm(range(1000)):  # 1000 шагов обучения
+        # Генерация случайных данных
+        x = torch.randn(batch_size, input_dim)
+        t = torch.randint(0, num_steps, (batch_size,))  # Случайные временные шаги
+
+        # Добавление шума
+        noisy_x, noise = add_noise(x, t)
+
+        # Прямой проход через энкодер
+        encoded = encoder(noisy_x, t)
+
+        # Прямой проход через декодер
+        decoded = decoder(encoded)
+
+        # Расчет потерь (например, MSE)
+        loss = nn.MSELoss()(decoded, x)
+
+        # Обратный проход и обновление весов
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+    print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')
+
+"""# ***SELF-AWARNESS AI***"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+from tqdm import tqdm
+
+# Гиперпараметры
+input_size = 10               # Размерность входных данных
+hidden_size = 20              # Размер скрытого слоя LSTM
+num_layers = 2                # Количество слоев LSTM
+seq_len = 5                   # Длина последовательности
+batch_size = 1                # Размер батча
+num_epochs = 5                # Количество эпох
+learning_rate = 1e-4          # Скорость обучения
+
+# Гиперпараметры для графовой нейросети
+gnn_params = {
+    'input_dim': input_size,         # Входной размер
+    'hidden_dim': 32,                # Скрытый размер первого слоя
+    'hidden_dim_2': 64,              # Скрытый размер второго слоя
+    'output_dim': input_size,        # Выходной размер
+    'activation_function': 'ReLU',   # Функция активации
+    'dropout_rate': 0.2,             # Дроп-аут
+    'batch_norm': True,              # Использовать батч-нормализацию
+}
+
+# Гиперпараметры для LSTM
+lstm_params = {
+    'input_size': input_size,         # Размерность входа
+    'hidden_size': hidden_size,       # Размер скрытого слоя
+    'num_layers': num_layers,         # Количество слоев
+    'dropout': 0.2,                   # Дроп-аут
+    'bidirectional': False,            # Двунаправленный LSTM
+    'activation_function': 'Tanh',    # Функция активации
+}
+
+# Определение графовой нейросети
+class GraphNeuralNetwork(nn.Module):
+    def __init__(self, params):
+        super(GraphNeuralNetwork, self).__init__()
+        self.fc1 = nn.Linear(params['input_dim'], params['hidden_dim'])
+        self.fc2 = nn.Linear(params['hidden_dim'], params['hidden_dim_2'])
+        self.fc3 = nn.Linear(params['hidden_dim_2'], params['output_dim'])
+        self.dropout = nn.Dropout(params['dropout_rate'])
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = self.dropout(x)
+        x = F.relu(self.fc2(x))
+        x = self.dropout(x)
+        return self.fc3(x)  # Возвращаем выходный размер равный input_size
+
+# Определение модели LSTM
+class LSTMPredictor(nn.Module):
+    def __init__(self, params):
+        super(LSTMPredictor, self).__init__()
+        self.lstm = nn.LSTM(params['input_size'], params['hidden_size'], params['num_layers'],
+                            batch_first=True, dropout=params['dropout'])
+        self.fc = nn.Linear(params['hidden_size'], 1)
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        last_hidden = lstm_out[:, -1, :]
+        return self.fc(last_hidden)
+
+# Определение модели EmotionAwareness с GNN и LSTM
+class EmotionAwarenessModel(nn.Module):
+    def __init__(self, gnn_params, lstm_params):
+        super(EmotionAwarenessModel, self).__init__()
+        self.gnn = GraphNeuralNetwork(gnn_params)
+        self.lstm = LSTMPredictor(lstm_params)
+
+    def forward(self, x):
+        gnn_out = self.gnn(x)  # GNN output: shape (batch_size, input_size)
+        gnn_out = gnn_out.unsqueeze(1)  # Add sequence length dimension: shape (batch_size, 1, input_size)
+        return self.lstm(gnn_out)  # Pass to LSTM
+
+# Создание модели
+model = EmotionAwarenessModel(gnn_params, lstm_params)
+optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+# Пример данных (batch_size, input_size)
+x = torch.randn(batch_size, input_size)  # Should be (batch_size, input_size)
+target = torch.randn(batch_size, 1)  # Целевое значение
+
+# Обучение модели
+for epoch in range(num_epochs):
+    model.train()
+    optimizer.zero_grad()
+
+    # Прямой проход
+    output = model(x)
+
+    # Расчет потерь
+    loss = F.mse_loss(output, target)
+    loss.backward()
+
+    # Обновление параметров
+    optimizer.step()
+
+    print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')
+
+"""# ***NEW METHOD MACHINE LEARNING***"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch_geometric.nn import GCNConv
+from torch_geometric.data import Data
+import torch.nn.functional as F
+
+# Линейная регрессия для эталонного решения
+class LinearRegressionModel:
+    def init(self):
+        self.model = LinearRegression()
+
+    def fit(self, X, y):
+        self.model.fit(X, y)
+
+    def predict(self, X):
+        return self.model.predict(X)
+
+# Графовая нейросеть для подбора альтернативных решений
+class GraphNeuralNetwork(nn.Module):
+    def init(self, in_channels, out_channels):
+        super(GraphNeuralNetwork, self).init()
+        self.conv1 = GCNConv(in_channels, 16)
+        self.conv2 = GCNConv(16, out_channels)
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+        x = self.conv1(x, edge_index)
+        x = F.relu(x)
+        x = self.conv2(x, edge_index)
+        return x
+
+# Q-обучение с PPO
+class QLearningWithPPO:
+    def init(self, state_dim, action_dim, lr=0.001, gamma=0.99):
+        self.q_net = nn.Linear(state_dim, action_dim)
+        self.optimizer = optim.Adam(self.q_net.parameters(), lr=lr)
+        self.gamma = gamma
+        self.eps_clip = 0.2
+
+    def get_action(self, state):
+        q_values = self.q_net(state)
+        action = torch.argmax(q_values).item()
+        return action
+
+    def update(self, state, action, reward, next_state):
+        q_values = self.q_net(state)
+        q_next = self.q_net(next_state).detach()
+
+        target = reward + self.gamma * torch.max(q_next)
+        loss = F.mse_loss(q_values[action], target)
+
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+
+# Метод обучения логики
+def logic_learning_with_q_ppo(dataset, num_alternatives=10):
+    lin_model = LinearRegressionModel()
+    X, y = dataset[:, :-1], dataset[:, -1]
+    lin_model.fit(X, y)
+    base_solution = lin_model.predict(X)
+
+    gnn_model = GraphNeuralNetwork(in_channels=1, out_channels=1)
+    optimizer_gnn = optim.Adam(gnn_model.parameters(), lr=0.01)
+    q_ppo = QLearningWithPPO(state_dim=1, action_dim=num_alternatives)
+
+    edge_index = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)
+    x = torch.tensor(base_solution, dtype=torch.float).view(-1, 1)
+    data = Data(x=x, edge_index=edge_index)
+
+    for i in range(num_alternatives):
+        state = torch.tensor([i], dtype=torch.float)
+        action = q_ppo.get_action(state)
+
+        # Тренировка графовой сети
+        gnn_model.train()
+        for epoch in range(50):
+            optimizer_gnn.zero_grad()
+            out = gnn_model(data)
+            loss = F.mse_loss(out, x)
+            loss.backward()
+            optimizer_gnn.step()
+
+        solution = out.detach().numpy().flatten()
+        reward = -np.abs(base_solution - solution).sum()
+
+        next_state = torch.tensor([i + 1], dtype=torch.float)
+        q_ppo.update(state, action, reward, next_state)
+
+        print(f"Alternative solution {i+1}: reward = {reward}")
+
+    return solution
+
+"""# ***COMBINED MODELS  LIBERALMIND***"""
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch_geometric.nn import GCNConv
+from torch_geometric.data import Data
+import torch.nn.functional as F
+from sklearn.linear_model import LinearRegression
+
+# ��инейная регрессия для эталонного решения
+class LinearRegressionModel:
+    def __init__(self, params):
+        self.params = params
+        self.model = LinearRegression(
+            fit_intercept=params['fit_intercept'],
+            copy_X=params['copy_X'],
+            n_jobs=params['n_jobs']
+        )
+
+    def fit(self, X, y):
+        if self.params.get('normalize', False):
+            X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)
+        self.model.fit(X, y)
+
+    def predict(self, X):
+        return self.model.predict(X)
+
+# Графовая нейросеть для подбора альтернативных решений
+class GraphNeuralNetwork(nn.Module):
+    def __init__(self, params):
+        super(GraphNeuralNetwork, self).__init__()
+        self.conv1 = GCNConv(params['in_channels'], params['hidden_dim1'])
+        self.conv2 = GCNConv(params['hidden_dim1'], params['hidden_dim2'])
+        self.conv3 = GCNConv(params['hidden_dim2'], params['out_channels'])
+        self.dropout = params['dropout']
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+        x = self.conv1(x, edge_index)
+        x = F.relu(x)
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = self.conv2(x, edge_index)
+        x = F.relu(x)
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = self.conv3(x, edge_index)
+        return x
+
+# Q-обучение с PPO
+class QLearningWithPPO:
+    def __init__(self, state_dim, action_dim, lr=0.001, gamma=0.99):
+        self.q_net = nn.Linear(state_dim, action_dim)
+        self.optimizer = optim.Adam(self.q_net.parameters(), lr=lr)
+        self.gamma = gamma
+
+    def get_action(self, state):
+        q_values = self.q_net(state)
+        action = torch.argmax(q_values).item()
+        return action
+
+    def update(self, state, action, reward, next_state):
+        q_values = self.q_net(state)
+        q_next = self.q_net(next_state).detach()
+
+        target = reward + self.gamma * torch.max(q_next)
+        loss = F.mse_loss(q_values[action], target)
+
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+
+# Определение базовых нейросетей для примера
+class CreativeNet(nn.Module):
+    def __init__(self):
+        super(CreativeNet, self).__init__()
+        self.fc = nn.Linear(10, 20)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+class LogicNet(nn.Module):
+    def __init__(self):
+        super(LogicNet, self).__init__()
+        self.fc = nn.Linear(20, 30)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+class MathNet(nn.Module):
+    def __init__(self):
+        super(MathNet, self).__init__()
+        self.fc = nn.Linear(30, 40)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Общий класс для объединенной модели
+class CombinedModel(nn.Module):
+    def __init__(self, gnn_params):
+        super(CombinedModel, self).__init__()
+        self.creative_net = CreativeNet()
+        self.logic_net = LogicNet()
+        self.math_net = MathNet()
+        self.gnn_model = GraphNeuralNetwork(gnn_params)
+
+    def forward(self, x, data):
+        # Обработка через сети
+        x = self.creative_net(x)  # Первый этап - творчество
+        x = self.logic_net(x)      # Второй этап - логика
+        x = self.math_net(x)       # Третий этап - математика
+
+        # Обработка через графовую нейросеть
+        gnn_output = self.gnn_model(data)
+
+        return gnn_output  # Возвращаем выход графовой нейросети
+
+# Метод обучения логики с использованием Q-обучения и графовой нейросети
+def logic_learning_with_q_ppo(dataset, num_alternatives=10):
+    # Гиперпараметры для линейной регрессии
+    lin_params = {
+        'fit_intercept': True,
+        'copy_X': True,
+        'n_jobs': -1,
+        'normalize': False,  # Опция для нормализации данных, обработается в методе fit
+    }
+
+    # Гиперпараметры для графовой нейросети
+    gnn_params = {
+        'in_channels': 1,
+        'out_channels': 1,
+        'hidden_dim1': 16,
+        'hidden_dim2': 32,
+        'dropout': 0.2,
+    }
+
+    # Инициализация линейной регрессии и объединенной модели
+    lin_model = LinearRegressionModel(lin_params)
+    X, y = dataset[:, :-1], dataset[:, -1]
+    lin_model.fit(X, y)
+    base_solution = lin_model.predict(X)
+
+    q_ppo = QLearningWithPPO(state_dim=1, action_dim=num_alternatives)
+
+    # Создание графа
+    edge_index = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)
+    x = torch.tensor(base_solution, dtype=torch.float).view(-1, 1)
+    data = Data(x=x, edge_index=edge_index)
+
+    combined_model = CombinedModel(gnn_params)
+
+    for i in range(num_alternatives):
+        state = torch.tensor([i], dtype=torch.float)
+        action = q_ppo.get_action(state)
+
+        # Тренировка графовой сети
+        combined_model.train()
+        optimizer_gnn = optim.Adam(combined_model.parameters(), lr=0.01)
+        for epoch in range(50):
+            optimizer_gnn.zero_grad()
+            out = combined_model(torch.tensor(X, dtype=torch.float), data)  # Передача данных через объединенную модель
+            loss = F.mse_loss(out, x)
+            loss.backward()
+            optimizer_gnn.step()
+
+        solution = out.detach().numpy().flatten()
+        reward = -np.abs(base_solution - solution).sum()
+
+        next_state = torch.tensor([i + 1], dtype=torch.float)
+        q_ppo.update(state, action, reward, next_state)
+
+        print(f"Alternative solution {i + 1}: reward = {reward}")
+
+    return solution
+
+# Пример данных
+dataset = np.random.rand(100, 11)  # Пример: 100 примеров с 10 признаками и 1 целевой переменной
+solutions = logic_learning_with_q_ppo(dataset)
+
+# Создание объединенной модели и пример данных для входа
+combined_model = CombinedModel({
+    'in_channels': 1,
+    'out_channels': 1,
+    'hidden_dim1': 16,
+    'hidden_dim2': 32,
+    'dropout': 0.2,
+})
+
+input_data = torch.randn(1, 10)
+dummy_data = Data(x=input_data.view(-1, 1), edge_index=torch.tensor([[0, 1], [1, 0]], dtype=torch.long))
+output = combined_model(input_data, dummy_data)  # Передача dummy_data для GNN
+print("Output:", output)
+
+import random
+
+class QLearningWithPPO:
+    def init(self, state_dim, action_dim, lr=0.001, gamma=0.99, epsilon=0.1):
+        self.q_net = nn.Linear(state_dim, action_dim)
+        self.optimizer = optim.Adam(self.q_net.parameters(), lr=lr)
+        self.gamma = gamma
+        self.epsilon = epsilon  # Для epsilon-greedy стратегии
+        self.memory = []  # Хранение опытов для обучения
+
+    def get_action(self, state):
+        if random.random() < self.epsilon:  # Эpsilon-greedy стратегия
+            return random.randint(0, self.q_net.out_features - 1)
+        q_values = self.q_net(state)
+        action = torch.argmax(q_values).item()
+        return action
+
+    def update(self, batch_size):
+        if len(self.memory) < batch_size:
+            return
+
+        # Случайный выбор опыта из памяти
+        experiences = random.sample(self.memory, batch_size)
+        states, actions, rewards, next_states = zip(*experiences)
+
+        states = torch.stack(states)
+        actions = torch.tensor(actions)
+        rewards = torch.tensor(rewards)
+        next_states = torch.stack(next_states)
+
+        q_values = self.q_net(states)
+        q_next = self.q_net(next_states).detach()
+
+        target = rewards + self.gamma * torch.max(q_next, dim=1)[0]
+        loss = F.mse_loss(q_values.gather(1, actions.unsqueeze(1)), target.unsqueeze(1))
+
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+
+    def store_experience(self, state, action, reward, next_state):
+        self.memory.append((state, action, reward, next_state))
+
+# Метод обучения логики с использованием Q-обучения и графовой нейросети
+def logic_learning_with_q_ppo(dataset, num_epochs=100, batch_size=32, num_alternatives=10):
+    # Гиперпараметры для линейной регрессии
+    lin_params = {
+        'fit_intercept': True,
+        'copy_X': True,
+        'n_jobs': -1,
+        'normalize': False,
+    }
+
+    # Инициализация моделей
+    lin_reg_model = LinearRegressionModel()
+    lin_reg_model.init(lin_params)
+
+
+
+    # Инициализация графовой нейросети и Q-обучения с PPO
+    gnn_params = {
+        'in_channels': data.num_node_features,
+        'hidden_dim1': 16,
+        'hidden_dim2': 8,
+        'out_channels': 4,
+        'dropout': 0.5,
+    }
+    gnn_model = GraphNeuralNetwork(gnn_params)
+    q_ppo = QLearningWithPPO(state_dim=10, action_dim=4)  # Пример размерности состояния и действия
+
+    # Основной цикл обучения
+    for epoch in range(num_epochs):
+        state = torch.tensor(X, dtype=torch.float32)  # Преобразуем X в тензор
+        action = q_ppo.get_action(state)  # Получаем действие
+        reward = random.random()  # Пример получения вознаграждения (это должно быть заменено на реальную логику)
+        next_state = state  # В реальном сценарии next_state должен изменяться
+
+        # ��охраняем опыт
+        q_ppo.store_experience(state, action, reward, next_state)
+
+        # Обновляем модель каждые batch_size итераций
+        if (epoch + 1) % batch_size == 0:
+            q_ppo.update(batch_size)
+
+        # Вывод информации о текущем прогрессе
+        if (epoch + 1) % 10 == 0:
+            print(f"Эпоха {epoch + 1}/{num_epochs}, Вознаграждение: {reward:.4f}")
+
+    # Вывод предсказаний
+    print("Предсказания линейной регрессии:", y_pred)
+    print("Выход графовой нейросети:", gnn_model(data))
+
+"""# ***GENERATIVE MODEL***"""
+
+import torch
+import torch.nn as nn
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Box, Discrete
+from datasets import load_dataset
+
+# Модель творчества
+class CreativeNet(nn.Module):
+    def init(self):
+        super(CreativeNet, self).init()
+        self.fc = nn.Linear(32, 64)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Модель логики
+class LogicNet(nn.Module):
+    def init(self):
+        super(LogicNet, self).init()
+        self.fc = nn.Linear(64, 128)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Математическая модель
+class MathNet(nn.Module):
+    def init(self):
+        super(MathNet, self).init()
+        self.fc = nn.Linear(128, 32)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Объединённая модель
+class CombinedModel(nn.Module):
+    def init(self):
+        super(CombinedModel, self).init()
+        self.creative_net = CreativeNet()
+        self.logic_net = LogicNet()
+        self.math_net = MathNet()
+
+    def forward(self, x):
+        x = self.creative_net(x)
+        x = self.logic_net(x)
+        x = self.math_net(x)
+        return x
+
+# Среда обучения
+class CustomEnv(Env):
+    def init(self, model, dataset):
+        super(CustomEnv, self).init()
+        self.model = model
+        self.dataset = dataset
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=0, high=1, shape=(32,), dtype=torch.float32)
+        self.current_index = 0
+
+    def reset(self):
+        self.current_index = 0
+        return self._get_observation()
+
+    def step(self, action):
+        observation = self._get_observation()
+        input_tensor = torch.tensor(observation, dtype=torch.float32).unsqueeze(0)
+        model_output = self.model(input_tensor).squeeze(0).detach().numpy()
+
+        # Логика вознаграждения на основе действий и вывода модели
+        reward = -1 if action != model_output.argmax() else 1
+        self.current_index += 1
+        done = self.current_index >= len(self.dataset)
+        return observation, reward, done, {}
+
+    def _get_observation(self):
+        return torch.tensor(self.dataset[self.current_index], dtype=torch.float32).numpy()
+
+
+# Загрузка датасета
+keyword = "/content/dataset/anthropic_hh_golden-test.arrow"
+dataset = load_dataset(keyword)["train"][:10]
+input_size = len(dataset[0])
+
+# Инициализация модели и среды
+model = CombinedModel()
+env = CustomEnv(model, dataset)
+
+# Настройка PPO
+ppo_model = PPO("MlpPolicy", env, verbose=1)
+ppo_model.learn(total_timesteps=10000)
+
+# Генерация ответа
+def generate_response(model, input_data):
+    input_tensor = torch.tensor(input_data, dtype=torch.float32).unsqueeze(0)
+    output = model(input_tensor).squeeze(0).detach().numpy()
+    return output.argmax()
+
+# Пример генерации
+example_input = torch.rand(32).numpy()
+generated_response = generate_response(model, example_input)
+print("Generated response:", generated_response)
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch_geometric.data import Data
+from datasets import load_dataset
+from sklearn.preprocessing import StandardScaler
+import numpy as np
+from tqdm import tqdm
+
+# Универсальная объединённая модель
+class CombinedModel(nn.Module):
+    def init(self, input_size, hidden_size, output_size):
+        super(CombinedModel, self).init()
+        # Энкодер на основе LSTM
+        self.encoder = nn.LSTM(input_size, hidden_size, batch_first=True)
+        # Графовая нейросеть
+        self.gnn_fc1 = nn.Linear(hidden_size, 64)
+        self.gnn_fc2 = nn.Linear(64, hidden_size)
+        # Декодер на основе LSTM
+        self.decoder = nn.LSTM(hidden_size, output_size, batch_first=True)
+
+    def forward(self, x, edge_index=None):
+        # Энкодинг последовательностей
+        x, _ = self.encoder(x)
+        x = x[:, -1, :]  # Используем последний выход
+        # Обработка через GNN
+        x = torch.relu(self.gnn_fc1(x))
+        x = torch.relu(self.gnn_fc2(x))
+        # Декодинг
+        x = x.unsqueeze(1).repeat(1, 10, 1)  # Растягиваем для LSTM-декодера
+        x, _ = self.decoder(x)
+        return x
+
+# Функция загрузки и предобработки датасета
+def preprocess_dataset(dataset_name):
+    dataset = load_dataset(dataset_name)
+    # Преобразуем данные в numpy (или используем ваш подход)
+    if 'train' in dataset:
+        data = np.array(dataset['train'])
+    else:
+        data = np.array(dataset['data'])
+    # Масштабирование
+    scaler = StandardScaler()
+    scaled_data = scaler.fit_transform(data)
+    return torch.tensor(scaled_data, dtype=torch.float32)
+
+# Обучение модели
+def train_model(model, dataset, epochs=10, batch_size=32, learning_rate=1e-4):
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+    loss_fn = nn.MSELoss()
+    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+    for epoch in range(epochs):
+        total_loss = 0
+        for batch in tqdm(dataloader, desc=f"Epoch {epoch + 1}/{epochs}"):
+            inputs = batch[:, :-1].unsqueeze(1)  # Последний столбец - целевая переменная
+            targets = batch[:, -1].unsqueeze(1)
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_fn(outputs.squeeze(), targets)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        print(f"Loss: {total_loss / len(dataloader):.4f}")
+
+# Пример использования
+if name == "main":
+    # Параметры модели
+    input_size = 10
+    hidden_size = 128
+    output_size = 1
+
+    # Инициализация модели
+    model = CombinedModel(input_size, hidden_size, output_size)
+
+    # Загрузка и предобработка датасета
+    dataset_name = "your_dataset_name"  # Укажите название датасета
+    dataset = preprocess_dataset(dataset_name)
+
+    # Обучение модели
+    train_model(model, dataset)
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Box, Discrete
+import pandas as pd
+import os
+
+# *ШАГ 1: Объединение трех моделей в одну*
+
+class UnifiedModel(nn.Module):
+    def init(self, input_size, hidden_size, output_size):
+        super(UnifiedModel, self).init()
+        # LSTM-энкодер
+        self.encoder = nn.LSTM(input_size, hidden_size, batch_first=True)
+        # Логическая модель
+        self.logic_fc = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size * 2),
+            nn.ReLU(),
+            nn.Linear(hidden_size * 2, hidden_size)
+        )
+        # LSTM-декодер
+        self.decoder = nn.LSTM(hidden_size, output_size, batch_first=True)
+
+    def forward(self, x):
+        # Проходим через LSTM-энкодер
+        x, _ = self.encoder(x)
+        x = x[:, -1, :]  # Используем последний выход
+        # Пропускаем через логическую модель
+        x = self.logic_fc(x)
+        # Добавляем измерение времени для декодера
+        x = x.unsqueeze(1).repeat(1, 10, 1)
+        x, _ = self.decoder(x)
+        return x
+
+# *ШАГ 2: Работа с файлами любого формата*
+
+def load_dataset(file_path):
+    # Определяем тип файла
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext == '.csv':
+        data = pd.read_csv(file_path)
+    elif ext in ['.xls', '.xlsx']:
+        data = pd.read_excel(file_path)
+    elif ext == '.json':
+        data = pd.read_json(file_path)
+    elif ext == '.txt':
+        data = pd.read_csv(file_path, delimiter='\t')
+    else:
+        raise ValueError("Формат файла не поддерживается")
+
+    # Преобразуем в NumPy массив и масштабируем
+    data = data.select_dtypes(include=[np.number]).dropna()  # Оставляем только числовые данные
+    return torch.tensor(data.values, dtype=torch.float32)
+
+# *ШАГ 3: RLCF и PPO обучение*
+
+# Класс среды для PPO
+class CustomEnv(Env):
+    def init(self, data):
+        super(CustomEnv, self).init()
+        self.data = data
+        self.current_step = 0
+        self.action_space = Discrete(3)  # Пример: 3 действия
+        self.observation_space = Box(low=-np.inf, high=np.inf, shape=(data.shape[1],), dtype=np.float32)
+
+    def reset(self):
+        self.current_step = 0
+        return self.data[self.current_step]
+
+    def step(self, action):
+        self.current_step += 1
+        reward = np.random.random()  # Пример: случайная награда
+        done = self.current_step >= len(self.data)
+        return self.data[self.current_step % len(self.data)], reward, done, {}
+
+# Функция RLCF
+def train_with_rlcf(data):
+    # Random Forest классификатор
+    rf = RandomForestClassifier(n_estimators=100)
+    X, y = data[:, :-1], data[:, -1]
+    rf.fit(X, y)
+    feature_importances = rf.feature_importances_
+    return feature_importances
+
+# Функция PPO обучения
+def train_with_ppo(data):
+    env = CustomEnv(data)
+    model = PPO("MlpPolicy", env, verbose=1)
+    model.learn(total_timesteps=10000)
+    return model
+
+# *ШАГ 4: Интеграция с Google Colab*
+
+def main():
+    # Ввод пути к файлу
+    file_path = input("Введите путь к файлу в директории Google Colab: ")
+
+    # Загрузка датасета
+    data = load_dataset(file_path)
+    print(f"Датасет загружен! Размер: {data.shape}")
+
+    # Инициализация модели
+    input_size = data.shape[1] - 1  # Предполагаем, что последний столбец - целевая переменная
+    hidden_size = 128
+    output_size = 1
+    model = UnifiedModel(input_size, hidden_size, output_size)
+
+    # RLCF обучение
+    feature_importances = train_with_rlcf(data)
+    print("Feature Importances (RLCF):", feature_importances)
+
+    # PPO обучение
+    ppo_model = train_with_ppo(data)
+    print("PPO обучение завершено!")
+
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from stable_baselines3 import PPO
+from gym import Env
+from gym.spaces import Box, Discrete
+import pandas as pd
+
+
+# *ШАГ 1: Объединение трех моделей в одну*
+
+# Модель творчества
+class CreativeNet(nn.Module):
+    def init(self):
+        super(CreativeNet, self).init()
+        self.fc = nn.Linear(32, 64)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Модель логики
+class LogicNet(nn.Module):
+    def init(self):
+        super(LogicNet, self).init()
+        self.fc = nn.Linear(64, 128)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Математическая модель
+class MathNet(nn.Module):
+    def init(self):
+        super(MathNet, self).init()
+        self.fc = nn.Linear(128, 32)
+
+    def forward(self, x):
+        return torch.relu(self.fc(x))
+
+# Объединённая модель
+class CombinedModel(nn.Module):
+    def init(self):
+        super(CombinedModel, self).init()
+        self.creative_net = CreativeNet()
+        self.logic_net = LogicNet()
+        self.math_net = MathNet()
+
+    def forward(self, x):
+        x = self.creative_net(x)
+        x = self.logic_net(x)
+        x = self.math_net(x)
+        return x
+
+
+# *ШАГ 2: Загрузка данных из файла любого формата*
+
+def load_dataset(file_path):
+    try:
+        if file_path.endswith(('.csv', '.txt')):
+            data = pd.read_csv(file_path)
+        elif file_path.endswith(('.xls', '.xlsx')):
+            data = pd.read_excel(file_path)
+        elif file_path.endswith('.json'):
+            data = pd.read_json(file_path)
+        else:
+            raise ValueError(f"Формат файла {file_path} не поддерживается.")
+
+        # Оставляем только числовые данные и преобразуем их в Tensor
+        data = data.select_dtypes(include=[np.number]).dropna()
+        return torch.tensor(data.values, dtype=torch.float32)
+    except Exception as e:
+        print(f"Ошибка при загрузке файла: {e}")
+        return None
+
+
+# *ШАГ 3: RLCF и PPO обучение*
+
+# Класс среды для PPO
+class CustomEnv(Env):
+    def init(self, data):
+        super(CustomEnv, self).init()
+        self.data = data
+        self.current_step = 0
+        self.action_space = Discrete(3)
+        self.observation_space = Box(low=-np.inf, high=np.inf, shape=(data.shape[1],), dtype=np.float32)
+
+    def reset(self):
+        self.current_step = 0
+        return self.data[self.current_step]
+
+    def step(self, action):
+        self.current_step += 1
+        reward = np.random.random()  # Пример: случайная награда
+        done = self.current_step >= len(self.data)
+        return self.data[self.current_step % len(self.data)], reward, done, {}
+
+# Функция RLCF
+def train_with_rlcf(data):
+    rf = RandomForestClassifier(n_estimators=100)
+    X, y = data[:, :-1], data[:, -1]
+    rf.fit(X, y)
+    return rf.feature_importances_
+
+# Класс среды для PPO
+class CustomEnv(Env):
+    def init(self, data):
+        super(CustomEnv, self).init()
+        self.data = data.numpy()  # Преобразуем данные в numpy
+        self.current_step = 0
+        self.action_space = Discrete(3)  # Пример: 3 возможных действия
+        self.observation_space = Box(
+            low=-np.inf, high=np.inf, shape=(self.data.shape[1] - 1,), dtype=np.float32
+        )
+
+    def reset(self):
+        # Сбрасываем текущий шаг
+        self.current_step = 0
+        # Возвращаем первое наблюдение (все признаки кроме последнего, который мы предполагаем как целевую переменную)
+        return self.data[self.current_step, :-1].astype(np.float32)
+
+    def step(self, action):
+        # Генерация случайной награды на основе действия (пример)
+        reward = float(np.random.random())
+        # Переход к следующему шагу
+        self.current_step += 1
+        # Проверяем, завершён ли эпизод
+        done = self.current_step >= len(self.data)
+        # Возвращаем следующее наблюдение, награду, статус завершения и пустой словарь информации
+        obs = self.data[self.current_step % len(self.data), :-1].astype(np.float32)
+        return obs, reward, done, {}
+
+def main():
+    # Ввод пути к файлу
+    file_path = input("Введите путь к вашему файлу в Google Colab: ").strip()
+    data = load_dataset(file_path)
+
+    if data is None:
+        print("Не удалось загрузить датасет.")
+        return
+
+    print(f"Датасет успешно загружен! Размер данных: {data.shape}")
+
+    # Инициализация объединённой модели
+    model = CombinedModel()
+    print("Объединённая модель создана!")
+
+    # RLCF обучение
+    feature_importances = train_with_rlcf(data)
+    print("Feature Importances (RLCF):", feature_importances)
+
+    # PPO обучение
+    ppo_model = train_with_ppo(data)
+    print("PPO обучение завершено!")
+
+
+# Запуск
+main()