Respan Dataset Explorer

а давай в качеств нейросети забабахаем вот такое:
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    # Attention and Normalization
    x = layers.MultiHeadAttention(
        key_dim=head_size, num_heads=num_heads, dropout=dropout
    )(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    # Feed Forward Part
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res
def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = keras.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return keras.Model(inputs, outputs)
input_shape = x_train.shape[1:]
n_classes = len(y_train.unique())
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=keras.optimizers.Adam(learning_rate=1e-4),
    metrics=["sparse_categorical_accuracy"],
)
model.summary()
callbacks = [keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    x_train,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
)
model.evaluate(x_test, y_test, verbose=1)

Да, вы можете адаптировать свою нейросеть для использования Transformer в качестве мета-классификатора в стекинге. Ваш код вроде бы уже готов к этому, но я дам некоторые дополнительные пояснения и инструменты, чтобы сделать интеграцию с уже обученными классификаторами.

Вот как можно организовать процесс с использованием вашего Transformer-кодека в качестве мета-классификатора в стекинге:

### Полный код с интеграцией стекинга и Transformer

```python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# Предположим, что у вас уже есть X_train, y_train и другие подготовленные данные.

# 1. Обучаем базовые классификаторы и получаем их предсказания
meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний

for i, (name, clf) in enumerate(classifiers.items()):
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем модель Transformer
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    x = layers.MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res

def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = layers.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return models.Model(inputs, outputs)

# Преобразование мета-признаков для модели Transformer
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)

model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=["sparse_categorical_accuracy"],
)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    meta_X_train_reshaped,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
)

# 3. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))
```

### Объяснение изменений:

1. **Массив мета-признаков**: Базовые классификаторы обучаются, и их вероятностные предсказания для положительного класса собираются в `meta_X_train`. Затем мы преобразуем его в формат `(samples, features, channels)` для использования с Transformer, где channels равен 1.

2. **Соответствующая форма ввода**: В функции `build_model` мы устанавливаем размерность входа, чтобы она соответствовала ожидаемому формату для нейросети.

3. **Предсказания и оценка**: Мы получаем предсказания для тестовых данных аналогичным образом, преобразовывая их так, чтобы они были совместимы с моделью Transformer.

### Заключение

Теперь в качестве мета-классификатора вы используете архитектуру трансформера. Это может быть мощным инструментом для улучшения прогноза, так как трансформеры способны понимать сложные паттерны и зависимости в данных. Если у вас есть дополнительные вопросы или потребуются ещё какие-либо улучшения, дайте знать!

и давай теперь немного переиграем выборки. вот код для формирования выборок
from imblearn.under_sampling import RandomUnderSampler
from sklearn.model_selection import train_test_split

X = df[features_cols]
y = df['class_in']

# Установите подвыборку
rus = RandomUnderSampler(random_state=42)
X_resampled, y_resampled = rus.fit_resample(X, y)

# Проверяем сбалансированный результат
print(pd.Series(y_resampled).value_counts())
X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42, stratify=y_resampled)
давай сделаем так- X_train, y_train должны быть resampled иначе просто модели плохо учатся. а вот X_test, y_test не семплированы так как в реальной работе они семплированы быть не могут (логично, да?)

Да, вы правильно рассуждаете. В большинстве случаев в процессе обучения модели вы хотите использовать сбалансированную выборку, чтобы обеспечить более эффективное обучение, особенно в условиях несбалансированных классов. При этом тестовая выборка должна сохранять оригинальное распределение классов, чтобы более точно оценить производительность модели на реальных данных.

Вот как вы можете организовать процесс, чтобы сбалансировать только обучающую выборку (`X_train`, `y_train`), а тестовая выборка (`X_test`, `y_test`) оставалась неизменной:

### Обновленный код

```python
from imblearn.under_sampling import RandomUnderSampler
from sklearn.model_selection import train_test_split
import pandas as pd

# Предположим, что df уже загружен и содержит ваши данные
X = df[features_cols]
y = df['class_in']

# Разделяем данные на обучающую и тестовую выборки
X_train_temp, X_test, y_train_temp, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Устанавливаем подвыборку только для обучающей выборки
rus = RandomUnderSampler(random_state=42)
X_train, y_train = rus.fit_resample(X_train_temp, y_train_temp)

# Проверяем сбалансированный результат для обучающей выборки
print("Training set class distribution:\n", pd.Series(y_train).value_counts())
print("Test set class distribution:\n", pd.Series(y_test).value_counts())

# Теперь вы можете использовать X_train, y_train для обучения моделей и X_test, y_test для оценки
```

### Объяснение изменений:

1. **Разделение на временные выборки**: Мы сначала разделили оригинальные данные на обучающую (`X_train_temp`, `y_train_temp`) и тестовую выборку (`X_test`, `y_test`). Здесь используем `stratify=y`, чтобы сохранить пропорции классов в тестовой выборке.

2. **Даунсемплинг**: Затем мы применяем `RandomUnderSampler` только к обучающей выборке, чтобы сбалансировать классы.

3. **Проверка распределения**: После этого мы выводим количество представителей каждого класса для обеих выборок, чтобы подтвердить их состояние (обучающая выборка — сбалансирована; тестовая выборка — оригинальная).

Теперь у вас есть сбалансированная обучающая выборка и неизмененная тестовая выборка, и вы можете использовать их для обучения и оценки своей модели. Если у вас возникнут дополнительные вопросы, дайте знать!

а давай чуть не так- сначала разделим df на df_train и df_test (при том лучше если что-то вроде df_train = df.iloc[-len(df)*(1-test_size)]), а потом будем разбивать и ресемплировать

Конечно! Вы можете сначала разделить ваш датафрейм `df` на обучающий (`df_train`) и тестовый (`df_test`) наборы, а затем из обучающего набора извлечь характеристики (`X_train`) и целевую переменную (`y_train`), после чего провести даунсемплинг. 

Ниже приведен пример того, как это можно сделать:

### Обновленный код

```python
import pandas as pd
from imblearn.under_sampling import RandomUnderSampler

# Предположим, что df уже загружен и содержит ваши данные
# Установите параметр для тестовой выборки
test_size = 0.2  # Например, 20% на тест
n_test = int(len(df) * test_size)

# Разделяем dataframe на df_train и df_test
df_train = df.iloc[:-n_test]  # Все строки, кроме последних n_test
df_test = df.iloc[-n_test:]    # Последние n_test строк

# Извлекаем X и y для обучающей выборки
X_train = df_train[features_cols]
y_train = df_train['class_in']

# Извлекаем X и y для тестовой выборки
X_test = df_test[features_cols]
y_test = df_test['class_in']

# Устанавливаем подвыборку (даунсемплинг) только для обучающей выборки
rus = RandomUnderSampler(random_state=42)
X_train, y_train = rus.fit_resample(X_train, y_train)

# Проверяем сбалансированный результат для обучающей выборки
print("Training set class distribution after resampling:\n", pd.Series(y_train).value_counts())
print("Test set class distribution:\n", pd.Series(y_test).value_counts())
```

### Объяснение изменений:

1. **Определение размера тестовой выборки**: Параметр `test_size` определяет, какую долю данных мы хотим использовать для тестирования. Мы вычисляем количество тестовых наблюдений, используя `int(len(df) * test_size)`.

2. **Разделение на обучающую и тестовую выборки**: Мы используем `iloc` для разделения `df` на `df_train` и `df_test`. Значения в `df_test` берутся из последних `n_test` строк, а в `df_train` — из всех предыдущих строк.

3. **Извлечение признаков и целевых переменных**: Мы извлекаем характеристики и целевые переменные как для тренировочной, так и для тестовой выборки.

4. **Даунсемплинг**: Применяем `RandomUnderSampler` только к обучающей выборке для сбалансирования классов.

5. **Проверка распределения**: После даунсемплинга мы проверяем распределения классов в обеих выборках, чтобы убедиться, что они сбалансированы в обучающей выборке и исходные размеры сохранены в тестовой выборке.

Теперь у вас есть подготовленная выборка, где обучающая выборка сбалансирована, а тестовая — соответствует оригинальному распределению. Если есть дополнительные вопросы или нужно что-то уточнить, дайте знать!

супер. теперь такой вопрос- мне критически важна precision на классе 1. на втором месте recall  на классе 1 (но уже не настолько). остальное меня мало волнует. как мне в обучение загнать именно эту метрику, чтобы нейросеть оптимизировала ответы под нее?

Если вам критически важна точность (precision) и полнота (recall) для класса 1, вы можете использовать взвешенные метрики или кастомные функции потерь при обучении нейронной сети. Вот несколько подходов, которые помогут оптимизировать эти метрики при обучении вашей модели.

### 1. Взвешенная Функция Потерь

Вы можете использовать вес, пропорциональный значимости каждого класса, чтобы ваша модель оптимизировала свою производительность, минимизируя потери для более важных классов. Один из способов сделать это — использовать параметр `class_weight` в функциях потерь, если вы используете логистическую регрессию или другие алгоритмы `scikit-learn`. В случае нейросетей вы можете реализовать кастомную функцию потерь или использовать уже существующую.

### 2. Использование Кастомной Функции Потерь

Для кастомной функции потерь, которая оптимизирует precision и recall, вы можете создать функцию, которая учитывает эти метрики. Например, вы можете создать функцию потерь, основанную на F1-мере или просто прямую комбинацию precision и recall для класса 1.

#### Пример кастомной функции потерь:

```python
import tensorflow as tf
from keras import backend as K

def precision(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positive = K.sum(K.round(K.clip(y_pred, 0, 1)))
    return true_positive / (predicted_positive + K.epsilon())

def recall(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positive = K.sum(K.round(K.clip(y_true, 0, 1)))
    return true_positive / (possible_positive + K.epsilon())

def precision_recall_loss(y_true, y_pred):
    precision_value = precision(y_true, y_pred)
    recall_value = recall(y_true, y_pred)
    return 1 - precision_value + (1 - recall_value)

# Используем кастомную функцию потерь в модели
model.compile(
    loss=precision_recall_loss,  # или 'binary_crossentropy' с кастомной метрикой
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=[precision, recall]
)
```

### 3. Использование Weighted Metrics

Если вы хотите учесть вес для классов в расчете метрик, вы можете вычислить величины precision и recall с использованием весов. Вы можете использовать `class_weight` в `fit()`:

```python
from sklearn.utils.class_weight import compute_class_weight

# Вычисление весов классов
class_weights = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train)

# Обучение с использованием весов классов
model.fit(
    X_train,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
    class_weight={0: class_weights[0], 1: class_weights[1]}  # Указать классы 0 и 1
)
```

### 4. Оптимизация на основании конкретной метрики

Использование `EarlyStopping` и `ModelCheckpoint` также может помочь сосредоточиться на ваших метриках:

```python
from keras.callbacks import EarlyStopping, ModelCheckpoint

early_stopping = EarlyStopping(monitor='val_precision', patience=10, restore_best_weights=True)
model_checkpoint = ModelCheckpoint('best_model.h5', monitor='val_precision', save_best_only=True)

model.fit(
    X_train,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=[early_stopping, model_checkpoint],
)
```

### Резюме

1. **Кастомизация функции потерь**: Используйте кастомную функцию потерь, которая учитывает precision и recall для класса 1.
2. **Использование весов классов**: Применяйте `class_weight` для учета значимости классов в обучении.
3. **Оптимизация на конкретной метрике**: Используйте `EarlyStopping` и `ModelCheckpoint`, чтобы сосредоточиться именно на той метрике, которая вам важна.

Эти подходы помогут вам настраивать вашу нейронную сеть так, чтобы она хорошо работала на классе 1, особенно в отношении precision и recall. Если вам нужно больше информации по какому-то из пунктов, дайте знать!

и напомню, что у меня нейросеть это мета-классификатор в стекинге. вот код:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# Предположим, что у вас уже есть X_train, y_train и другие подготовленные данные.

# 1. Обучаем базовые классификаторы и получаем их предсказания
meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний

for i, (name, clf) in enumerate(classifiers.items()):
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем модель Transformer
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    x = layers.MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res

def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = layers.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return models.Model(inputs, outputs)

# Преобразование мета-признаков для модели Transformer
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)

model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=["sparse_categorical_accuracy"],
)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    meta_X_train_reshaped,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
)

# 3. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))
давай в нее влепим кастомную метрику про которую ты говорил
def precision(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positive = K.sum(K.round(K.clip(y_pred, 0, 1)))
    return true_positive / (predicted_positive + K.epsilon())

def recall(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positive = K.sum(K.round(K.clip(y_true, 0, 1)))
    return true_positive / (possible_positive + K.epsilon())

def precision_recall_loss(y_true, y_pred):
    precision_value = precision(y_true, y_pred)
    recall_value = recall(y_true, y_pred)
    return 1 - precision_value + (1 - recall_value)

Вы можете внедрить кастомные метрики и функцию потерь в вашу модель-мета-классификатор, чтобы оптимизировать ее на основе precision и recall для класса 1. Voici как это можно сделать:

### Полный код с кастомными метриками и функцией потерь

```python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models, backend as K
import tensorflow as tf

# 1. Обучаем базовые классификаторы и получаем их предсказания
meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний

for i, (name, clf) in enumerate(classifiers.items()):
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем кастомные метрики и функцию потерь
def precision(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positive = K.sum(K.round(K.clip(y_pred, 0, 1)))
    return true_positive / (predicted_positive + K.epsilon())

def recall(y_true, y_pred):
    true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positive = K.sum(K.round(K.clip(y_true, 0, 1)))
    return true_positive / (possible_positive + K.epsilon())

def precision_recall_loss(y_true, y_pred):
    precision_value = precision(y_true, y_pred)
    recall_value = recall(y_true, y_pred)
    return 1 - precision_value + (1 - recall_value)

# 3. Создаем модель Transformer
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    x = layers.MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res

def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = layers.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return models.Model(inputs, outputs)

# Преобразование мета-признаков для модели Transformer
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)

# Компиляция модели с кастомной функцией потерь и метриками
model.compile(
    loss=precision_recall_loss,  # Используем кастомную функцию потерь
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=[precision, recall]
)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    meta_X_train_reshaped,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
)

# 4. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))
```

### Объяснение изменений:

1. **Кастомные метрики**: Добавлены функции `precision`, `recall` и `precision_recall_loss`, которые оптимизируют модель в соответствии с вашими требованиями.

2. **Компиляция модели**: При компиляции модели используется кастомная функция потерь `precision_recall_loss`, а также метрики precision и recall, чтобы отслеживать их во время обучения.

3. **Обучение**: Модель обучается так же, как и раньше, но теперь с использованием новых метрик и функции потерь.

### Примечания

- **Кастомная функция потерь**: Если модель не сходится, вы можете рассмотреть возможность настройки функции потерь или метрик. Например, можно поэкспериментировать с весами в функциях precision и recall.
  
- **Сложность обучения**: При обучении с кастомными функциями потерь и метриками модель может требовать большего количества эпох или корректировок гиперпараметров. Старайтесь следить за метриками на валидационной выборке, чтобы избежать переобучения.

Если у вас будут дополнительные вопросы или потребуется дополнительная помощь, дайте знать!

Cell In[15], line 37, in precision_recall_loss(y_true, y_pred)
     36 def precision_recall_loss(y_true, y_pred):
---> 37     precision_value = precision(y_true, y_pred)
     38     recall_value = recall(y_true, y_pred)
     39     return 1 - precision_value + (1 - recall_value)

Cell In[15], line 27, in precision(y_true, y_pred)
     26 def precision(y_true, y_pred):
---> 27     true_positive = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
     28     predicted_positive = K.sum(K.round(K.clip(y_pred, 0, 1)))
     29     return true_positive / (predicted_positive + K.epsilon())

AttributeError: module 'keras.backend' has no attribute 'sum'

Ошибка, которую вы получили, связана с тем, что Keras (в последних версиях) не находит атрибута `sum` в `keras.backend`. Вместо этого вам нужно использовать `tf.reduce_sum`, если Keras встроен в TensorFlow, что наиболее распространено в современных версиях.

Давайте исправим функцию `precision`, `recall` и `precision_recall_loss`, чтобы использовать TensorFlow в качестве backend, и все будет работать корректно.

Вот более корректная версия ваших кастомных функций:

### Обновлённый код кастомных метрик и функции потерь

```python
import tensorflow as tf

def precision(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    predicted_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_pred, 0, 1)))
    return true_positive / (predicted_positive + tf.keras.backend.epsilon())

def recall(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    possible_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true, 0, 1)))
    return true_positive / (possible_positive + tf.keras.backend.epsilon())

def precision_recall_loss(y_true, y_pred):
    precision_value = precision(y_true, y_pred)
    recall_value = recall(y_true, y_pred)
    return 1 - precision_value + (1 - recall_value)
```

### Основные изменения:

1. **Использование `tf.reduce_sum`**: Теперь в функциях `precision` и `recall` используется `tf.reduce_sum` для вычисления суммы, что предотвращает возникновение ошибок, связанных с недоступностью `sum` в `keras.backend`.

2. **Используйте `tf.clip_by_value` вместо `K.clip`**: Это также обновление для совместимости с TensorFlow.

После этих изменений, функции будут корректно работать в вашей модели.

### Полный интегрированный код

Вот как будет выглядеть интеграция кастомных метрик и функции потерь в ваш код:

```python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# 1. Обучаем базовые классификаторы и получаем их предсказания
meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))

for i, (name, clf) in enumerate(classifiers.items()):
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]

# 2. Кастомные метрики
def precision(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    predicted_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_pred, 0, 1)))
    return true_positive / (predicted_positive + tf.keras.backend.epsilon())

def recall(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    possible_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true, 0, 1)))
    return true_positive / (possible_positive + tf.keras.backend.epsilon())

def precision_recall_loss(y_true, y_pred):
    precision_value = precision(y_true, y_pred)
    recall_value = recall(y_true, y_pred)
    return 1 - precision_value + (1 - recall_value)

# 3. Создаем модель Transformer
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    x = layers.MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res

def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = layers.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return models.Model(inputs, outputs)

# Преобразование мета-признаков для модели Transformer
input_shape = (meta_X_train.shape[1], 1)
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)

# Компиляция модели с кастомной функцией потерь и метриками
model.compile(
    loss=precision_recall_loss,
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=[precision, recall]
)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    meta_X_train_reshaped,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
)

# 4. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))
```

После внесения изменений все должны работать правильно. Если возникнут другие вопросы или потребуются дополнительные разъяснения, дайте знать!

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[16], line 100
     98 # Обучение мета-классификатора
     99 callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
--> 100 model.fit(
    101     meta_X_train_reshaped,
    102     y_train,
    103     validation_split=0.2,
    104     epochs=100,
    105     batch_size=64,
    106     callbacks=callbacks,
    107 )
    109 # 4. Получаем предсказания для тестового набора
    110 meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))

File C:\ProgramData\anaconda3\Lib\site-packages\keras\src\utils\traceback_utils.py:122, in filter_traceback.<locals>.error_handler(*args, **kwargs)
    119     filtered_tb = _process_traceback_frames(e.__traceback__)
    120     # To get the full stack trace, call:
    121     # `keras.config.disable_traceback_filtering()`
--> 122     raise e.with_traceback(filtered_tb) from None
    123 finally:
    124     del filtered_tb

File C:\ProgramData\anaconda3\Lib\site-packages\keras\src\optimizers\base_optimizer.py:772, in BaseOptimizer._filter_empty_gradients(self, grads, vars)
    769             missing_grad_vars.append(v.name)
    771 if not filtered_grads:
--> 772     raise ValueError("No gradients provided for any variable.")
    773 if missing_grad_vars:
    774     warnings.warn(
    775         "Gradients do not exist for variables "
    776         f"{list(reversed(missing_grad_vars))} when minimizing the loss."
    777         " If using `model.compile()`, did you forget to provide a "
    778         "`loss` argument?"
    779     )

ValueError: No gradients provided for any variable.

Ошибка `ValueError: No gradients provided for any variable` часто возникает, когда данные, переданные в модель, не соответствуют ожиданиям в плане формы, либо когда функция потерь применяется неправильно, и Keras не может вычислить градиенты для обновления параметров модели.

### Возможные причины и их решения:

1. **Проблема с формой входных данных**:
   Убедитесь, что `meta_X_train_reshaped` имеет правильную форму `(num_samples, num_features, 1)`, а `y_train` — правильную форму `(num_samples,)`. Это может вызвать проблемы, если, например, `num_features` равен 0.

   Проверьте форму:
   ```python
   print(meta_X_train_reshaped.shape)  # Ожидается: (n_samples, n_classes, 1)
   print(y_train.shape)  # Ожидается: (n_samples,)
   ```

2. **Кастомная функция потерь**:
   Возможно, кастомная функция потерь неправильно работает, если не может вычислить значения для входных переменных. Вы можете попробовать отладить `precision_recall_loss`, добавив выводы внутри функции для проверки значений `y_true` и `y_pred`. 

3. **Инициализация и инициализация `model.fit()`**:
   Также убедитесь, что вы правильно инициализировали модель и вызываете `model.fit()`, если вы вносили изменения в модель между вызовами.

### Обновленный код с добавленными проверками

Вот как вы можете улучшить код, добавив проверки форм:

```python
# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=4,
    ff_dim=4,
    num_transformer_blocks=4,
    mlp_units=[128],
    mlp_dropout=0.4,
    dropout=0.25,
)

# Компиляция модели с кастомной функцией потерь и метриками
model.compile(
    loss=precision_recall_loss,
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=[precision, recall]
)

# Проверьте форму входных данных
print("Shape of meta_X_train_reshaped:", meta_X_train_reshaped.shape)
print("Shape of y_train:", y_train.shape)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
try:
    model.fit(
        meta_X_train_reshaped,
        y_train,
        validation_split=0.2,
        epochs=100,
        batch_size=64,
        callbacks=callbacks,
    )
except Exception as e:
    print("Error during training:", e)

# 4. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))
```

### Дополнительные проверки:
- Убедитесь, что вам нужно передать `y_train` в одномерном виде, то есть он должен быть просто вектором меток.
- Если проблема не решится, попробуйте временно использовать стандартную функцию потерь, такую как `sparse_categorical_crossentropy`, чтобы проверить, работает ли модель без кастомной функции потерь.

Если у вас остались вопросы или если вы хотите дополнительно проверить что-то, дайте знать!

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# Предположим, что у вас уже есть X_train, y_train и другие подготовленные данные.

# 1. Обучаем базовые классификаторы и получаем их предсказания

classifiers = {
    'Logistic Regression': LogisticRegression(),
    'Random Forest': RandomForestClassifier(),
    'Gradient Boosting': GradientBoostingClassifier(),
    # 'Support Vector Machine': SVC(probability=True),
    'K-Nearest Neighbors': KNeighborsClassifier(),
    'xgboost': XGBClassifier(scale_pos_weight=1),
    'lightgbm': LGBMClassifier(),
    'catboost': CatBoostClassifier(verbose=0),
    # 'naive_bayes': GaussianNB(),
    'ada_boost': AdaBoostClassifier(),
    'lda': LinearDiscriminantAnalysis(),
}
meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний
for i, (name, clf) in enumerate(classifiers.items()):
    print(name)
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем модель Transformer
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    x = layers.MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)
    x = layers.Dropout(dropout)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    res = x + inputs
    x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation="relu")(res)
    x = layers.Dropout(dropout)(x)
    x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)
    x = layers.LayerNormalization(epsilon=1e-6)(x)
    return x + res

def build_model(
    input_shape,
    head_size,
    num_heads,
    ff_dim,
    num_transformer_blocks,
    mlp_units,
    dropout=0,
    mlp_dropout=0,
):
    inputs = layers.Input(shape=input_shape)
    x = inputs
    for _ in range(num_transformer_blocks):
        x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
    x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
    for dim in mlp_units:
        x = layers.Dense(dim, activation="relu")(x)
        x = layers.Dropout(mlp_dropout)(x)
    outputs = layers.Dense(n_classes, activation="softmax")(x)
    return models.Model(inputs, outputs)

# Преобразование мета-признаков для модели Transformer
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем Transformer
n_classes = len(np.unique(y_train))
model = build_model(
    input_shape,
    head_size=256,
    num_heads=2,
    ff_dim=64,
    num_transformer_blocks=4,
    mlp_units=[128, 64],
    mlp_dropout=0.,
    dropout=0.,
)

model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
    metrics=["sparse_categorical_accuracy"],
)

# Обучение мета-классификатора
callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
model.fit(
    meta_X_train_reshaped,
    y_train,
    validation_split=0.1,
    epochs=25,
    batch_size=64,
    callbacks=callbacks,
)

# 3. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred = np.argmax(model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность мета-классификатора
print("Meta-classifier Performance:")
print(classification_report(y_test, y_meta_pred))
print(confusion_matrix(y_test, y_meta_pred))

а давай заменим трансформер на простую нейросеть. лучше даже на три (на тестирование. хочу посмотреть как себя покажут полносвязные, сверточные и рекуррентные сети)

Конечно! Вы можете заменить Transformer на три различных типа нейронных сетей: полностью связанные (Dense), сверточные (Convolutional) и рекуррентные (Recurrent). Я добавлю примеры каждой из этих сетей, чтобы вы могли протестировать их.

### Обновленный код с тремя моделями

Вот полный код с интеграцией полносвязной, сверточной и рекуррентной нейронной сети в качестве мета-классификаторов:

```python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# 1. Обучаем базовые классификаторы и получаем их предсказания
classifiers = {
    'Logistic Regression': LogisticRegression(),
    'Random Forest': RandomForestClassifier(),
    'Gradient Boosting': GradientBoostingClassifier(),
    'K-Nearest Neighbors': KNeighborsClassifier(),
    'xgboost': XGBClassifier(scale_pos_weight=1),
    'lightgbm': LGBMClassifier(),
    'catboost': CatBoostClassifier(verbose=0),
    'ada_boost': AdaBoostClassifier(),
    'lda': LinearDiscriminantAnalysis(),
}

meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний
for i, (name, clf) in enumerate(classifiers.items()):
    print(name)
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем полносвязную нейронную сеть
def build_dense_model(input_shape, n_classes):
    model = models.Sequential()
    model.add(layers.Flatten(input_shape=input_shape))
    model.add(layers.Dense(128, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(n_classes, activation='softmax'))
    return model

# 3. Создаем сверточную нейронную сеть
def build_cnn_model(input_shape, n_classes):
    model = models.Sequential()
    model.add(layers.Conv1D(64, kernel_size=2, activation='relu', input_shape=input_shape))
    model.add(layers.MaxPooling1D(pool_size=2))
    model.add(layers.Conv1D(32, kernel_size=2, activation='relu'))
    model.add(layers.MaxPooling1D(pool_size=2))
    model.add(layers.Flatten())
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(n_classes, activation='softmax'))
    return model

# 4. Создаем рекуррентную нейронную сеть
def build_rnn_model(input_shape, n_classes):
    model = models.Sequential()
    model.add(layers.LSTM(64, input_shape=input_shape))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(n_classes, activation='softmax'))
    return model

# Преобразование мета-признаков для моделирования
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем нейронные сети
n_classes = len(np.unique(y_train))

# Полносвязная нейронная сеть
dense_model = build_dense_model(input_shape, n_classes)
dense_model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4), metrics=['accuracy'])
dense_model.fit(meta_X_train_reshaped, y_train, validation_split=0.1, epochs=25, batch_size=64)

# Сверточная нейронная сеть
cnn_model = build_cnn_model(input_shape, n_classes)
cnn_model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4), metrics=['accuracy'])
cnn_model.fit(meta_X_train_reshaped, y_train, validation_split=0.1, epochs=25, batch_size=64)

# Рекуррентная нейронная сеть
rnn_model = build_rnn_model(input_shape, n_classes)
rnn_model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4), metrics=['accuracy'])
rnn_model.fit(meta_X_train_reshaped, y_train, validation_split=0.1, epochs=25, batch_size=64)

# 5. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью каждой модели мета-классификатора
y_meta_pred_dense = np.argmax(dense_model.predict(meta_X_test_reshaped), axis=-1)
y_meta_pred_cnn = np.argmax(cnn_model.predict(meta_X_test_reshaped), axis=-1)
y_meta_pred_rnn = np.argmax(rnn_model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность каждой модели
print("Dense Model Performance:")
print(classification_report(y_test, y_meta_pred_dense))
print(confusion_matrix(y_test, y_meta_pred_dense))

print("CNN Model Performance:")
print(classification_report(y_test, y_meta_pred_cnn))
print(confusion_matrix(y_test, y_meta_pred_cnn))

print("RNN Model Performance:")
print(classification_report(y_test, y_meta_pred_rnn))
print(confusion_matrix(y_test, y_meta_pred_rnn))
```

### Объяснение изменений:

1. **Три модели**: Код теперь включает три различные архитектуры: полносвязную, сверточную и рекуррентную.
   - **Полносвязная модель**: Простой слоистый полносвязный классификатор.
   - **Сверточная модель**: Использует сверточные слои для обработки ввода.
   - **Рекуррентная модель**: Использует LSTM для обработки последовательных данных.

2. **Обучение каждого типа сети**: Каждая из моделей обучается отдельно на тех же мета-признаках (вероятностях, полученных от базовых классификаторов).

3. **Предсказания и оценка**: После обучения, предсказания для тестовых данных производятся каждым из моделей, и результаты выводятся с использованием `classification_report` и `confusion_matrix`.

### Примечание

Это позволит вам сравнить производительность различных архитектур на ваших данных. Вы можете экспериментировать с гиперпараметрами каждой модели, добавляя больше слоев, изменяя количество нейронов и так далее. Если вам нужно больше помощи или у вас есть дополнительные вопросы, дайте знать!

а получится заменить в обучении метрику на precision?

Да, вы можете заменить метрику на `precision` для ваших моделей в `Keras`. Для этого вы просто задаете метрику в функции `compile()`. 

Если вы хотите использовать кастомную функцию `precision` (как вы обсудили ранее), вам нужно будет немного адаптировать код, чтобы он работал с новой метрикой. Обратите внимание, что кастомная метрика `precision` должна возвращать значение, которое Keras может использовать для оценки модели.

### Шаги по замене метрики на `precision`:

1. Создайте кастомную функцию метрики для `precision`.
2. Используйте эту метрику при компиляции моделей.

Вот пример обновленного кода с добавлением кастомной метрики `precision`:

```python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import AdaBoostClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.metrics import classification_report, confusion_matrix
from keras import layers, models
import tensorflow as tf

# Кастомная метрика precision
def precision(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    predicted_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_pred, 0, 1)))
    return true_positive / (predicted_positive + tf.keras.backend.epsilon())

# 1. Обучаем базовые классификаторы и получаем их предсказания
classifiers = {
    'Logistic Regression': LogisticRegression(),
    'Random Forest': RandomForestClassifier(),
    'Gradient Boosting': GradientBoostingClassifier(),
    'K-Nearest Neighbors': KNeighborsClassifier(),
    'xgboost': XGBClassifier(scale_pos_weight=1),
    'lightgbm': LGBMClassifier(),
    'catboost': CatBoostClassifier(verbose=0),
    'ada_boost': AdaBoostClassifier(),
    'lda': LinearDiscriminantAnalysis(),
}

meta_X_train = np.zeros((X_train.shape[0], len(classifiers)))  # Массив для хранения предсказаний
for i, (name, clf) in enumerate(classifiers.items()):
    print(name)
    clf.fit(X_train, y_train)
    meta_X_train[:, i] = clf.predict_proba(X_train)[:, 1]  # Получаем вероятности для положительного класса

# 2. Создаем полносвязную нейронную сеть
def build_dense_model(input_shape, n_classes):
    model = models.Sequential()
    model.add(layers.Flatten(input_shape=input_shape))
    model.add(layers.Dense(128, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(n_classes, activation='softmax'))
    return model

# Преобразование мета-признаков для моделирования
input_shape = (meta_X_train.shape[1], 1)  # Два измерения: количество базовых моделей и 1 признак
meta_X_train_reshaped = meta_X_train.reshape((meta_X_train.shape[0], meta_X_train.shape[1], 1))

# Обучаем нейронную сеть с precision как метрикой
n_classes = len(np.unique(y_train))

# Полносвязная нейронная сеть
dense_model = build_dense_model(input_shape, n_classes)
dense_model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4), metrics=[precision])
dense_model.fit(meta_X_train_reshaped, y_train, validation_split=0.1, epochs=25, batch_size=64)

# 3. Получаем предсказания для тестового набора
meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))
meta_X_test_reshaped = meta_X_test.reshape((meta_X_test.shape[0], meta_X_test.shape[1], 1))

for i, (name, clf) in enumerate(classifiers.items()):
    meta_X_test[:, i] = clf.predict_proba(X_test)[:, 1]

# Прогнозируем с помощью мета-классификатора
y_meta_pred_dense = np.argmax(dense_model.predict(meta_X_test_reshaped), axis=-1)

# Оцениваем производительность модели
print("Dense Model Performance:")
print(classification_report(y_test, y_meta_pred_dense))
print(confusion_matrix(y_test, y_meta_pred_dense))
```

### Изменения:

1. **Добавлена кастомная метрика**: Мы создали функцию `precision`, как вы определили, для использования в метриках `model.compile()`.
2. **Использование кастомной метрики**: При компиляции модели полносвязной нейронной сети метрика заменена на `precision`.

### Замечания:

- **Метрика precision не оптимизирует функцию потерь**: Обратите внимание, что замена метрики на `precision` не повлияет на функцию потерь (в данном случае `sparse_categorical_crossentropy`). Вы все равно будете минимизировать выбранную функцию потерь, в то время как модель будет отслеживать `precision` в процессе обучения.
- **Функция потерь должна быть адекватной**: Убедитесь, что используемая функция потерь адекватна для вашей задачи.

Вы можете проделать аналогичные изменения для сверточной и рекуррентной сетей. Если вам нужна помощь с этими архитектурами, дайте знать!

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[17], line 100
     98 # Обучение мета-классификатора
     99 callbacks = [tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
--> 100 model.fit(
    101     meta_X_train_reshaped,
    102     y_train,
    103     validation_split=0.2,
    104     epochs=100,
    105     batch_size=64,
    106     callbacks=callbacks,
    107 )
    109 # 4. Получаем предсказания для тестового набора
    110 meta_X_test = np.zeros((X_test.shape[0], len(classifiers)))

File C:\ProgramData\anaconda3\Lib\site-packages\keras\src\utils\traceback_utils.py:122, in filter_traceback.<locals>.error_handler(*args, **kwargs)
    119     filtered_tb = _process_traceback_frames(e.__traceback__)
    120     # To get the full stack trace, call:
    121     # `keras.config.disable_traceback_filtering()`
--> 122     raise e.with_traceback(filtered_tb) from None
    123 finally:
    124     del filtered_tb

File C:\ProgramData\anaconda3\Lib\site-packages\keras\src\optimizers\base_optimizer.py:772, in BaseOptimizer._filter_empty_gradients(self, grads, vars)
    769             missing_grad_vars.append(v.name)
    771 if not filtered_grads:
--> 772     raise ValueError("No gradients provided for any variable.")
    773 if missing_grad_vars:
    774     warnings.warn(
    775         "Gradients do not exist for variables "
    776         f"{list(reversed(missing_grad_vars))} when minimizing the loss."
    777         " If using `model.compile()`, did you forget to provide a "
    778         "`loss` argument?"
    779     )

ValueError: No gradients provided for any variable.

Ошибка `ValueError: No gradients provided for any variable.` обычно возникает, когда TensorFlow не может вычислить градиенты для обновления параметров модели. Это может произойти по нескольким причинам:

1. **Ошибка в форме данных**: Входные данные, переданные в модель, могут не соответствовать ожидаемым формам.
2. **Кастомная функция потерь**: Если кастомная функция потерь неправильно определена или имеет проблемы с расчетами, TensorFlow не сможет вычислить градиенты.
3. **Неправильные метрики**: Если метрики неправильно настроены, это также может привести к этой ошибке.

### Шаги по отладке проблемы

1. **Проверка форм входных данных**:
   Убедитесь, что `meta_X_train_reshaped` имеет форму `(num_samples, num_features, 1)` и что `y_train` имеет форму `(num_samples,)`.

   ```python
   print("Shape of meta_X_train_reshaped:", meta_X_train_reshaped.shape)
   print("Shape of y_train:", y_train.shape)
   ```

2. **Упрощение кастомных функций**:
   Временное отключение кастомной функции потерь и использование стандартной функции потерь может помочь установить, вызвана ли проблема кастомизацией.

3. **Использование стандартных метрик для проверки**:
   Временно используйте стандартные метрики (`accuracy`), чтобы изолировать проблему:

### Обновленный пример

Вот пример упрощенного кода на случай, если вы хотите протестировать с использованием стандартной функции потерь и метрики, чтобы установить стабильность модели:

```python
# Обучаем нейронные сети с использованием стандартных метрик
dense_model = build_dense_model(input_shape, n_classes)
dense_model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4), metrics=['accuracy'])

# Проверка форм
print("Shape of meta_X_train_reshaped:", meta_X_train_reshaped.shape)
print("Shape of y_train:", y_train.shape)

# Обучение с использованием стандартной потери
dense_model.fit(meta_X_train_reshaped, y_train, validation_split=0.1, epochs=25, batch_size=64)

# Получаем предсказания для тестового набора
# Код для получения предсказаний остается прежним...
```

### Если ошибка возникла только с кастомной метрикой:

Если ошибка возникает только с кастомной метрикой, вам может потребоваться проверить функцию `precision`:

- Убедитесь, что вы передаете правильные значения для `y_true` и `y_pred`.

Также вот улучшенная версия функции `precision` с добавленными отладочными выходами:

```python
def precision(y_true, y_pred):
    true_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_true * y_pred, 0, 1)))
    predicted_positive = tf.reduce_sum(tf.round(tf.clip_by_value(y_pred, 0, 1)))
    
    # Отладочная информация
    print("True Positives:", true_positive.numpy())
    print("Predicted Positives:", predicted_positive.numpy())
    
    return true_positive / (predicted_positive + tf.keras.backend.epsilon())
```

Если после всех этих шагов проблема сохраняется, попробуйте делиться информацией о том, где именно возникает ошибка, или дополнительными данными о вашем окружении (версии библиотек и т. д.), чтобы мы могли помочь более конкретно.