gpu

.gitignore

@@ -0,0 +1 @@
+env/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LEYA Lab for Natural Language Processing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,315 @@
+import gradio as gr
+import torchaudio
+import pandas as pd
+import torch.nn.functional as F
+import whisper
+import logging
+import plotly.express as px
+from utils.config_loader import ConfigLoader
+from data_loading.feature_extractor import (
+    PretrainedAudioEmbeddingExtractor,
+    PretrainedTextEmbeddingExtractor
+)
+import chardet
+import torch
+from models.models import BiFormer
+
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# DEVICE = torch.device('cpu')
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+# Constants with emojis and colors
+LABEL_TO_EMOTION = {
+    0: '😠 Anger',
+    1: '🤢 Disgust',
+    2: '😨 Fear',
+    3: '😄 Joy/Happiness',
+    4: '😐 Neutral',
+    5: '😢 Sadness',
+    6: '😲 Surprise/Enthusiasm'
+}
+EMOTION_COLORS = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEEAD', '#FF9999', '#D4A5A5']
+emotion_color_map = {emotion: color for emotion, color in zip(LABEL_TO_EMOTION.values(), EMOTION_COLORS)}
+TARGET_SAMPLE_RATE = 16000
+
+
+def initialize_components(config_path='config.toml'):
+    """Initialize configuration and models."""
+    config = ConfigLoader(config_path)
+    config.show_config()
+    model = BiFormer(
+        audio_dim=256,
+        text_dim=1024,
+        seg_len=95,
+        hidden_dim=256,
+        hidden_dim_gated=256,
+        num_transformer_heads=8,
+        num_graph_heads=2,
+        positional_encoding=False,
+        dropout=0.15,
+        mode='mean',
+        # device="cuda",
+        tr_layer_number=5,
+        out_features=256,
+        num_classes=7
+    )
+    checkpoint_path = "best_model_dev_0_5895_epoch_8.pt"
+    state = torch.load(checkpoint_path, map_location="cpu")
+    model.load_state_dict(state)
+    model = model.to(DEVICE)
+    model.eval()
+    return (
+        PretrainedAudioEmbeddingExtractor(config),
+        PretrainedTextEmbeddingExtractor(config),
+        whisper.load_model("base"),
+        model
+    )
+
+
+audio_extractor, text_extractor, whisper_model, bimodal_model = initialize_components()
+
+
+def load_and_preprocess_audio(audio_path):
+    """Load and preprocess audio to mono 16kHz format."""
+    try:
+        waveform, orig_sr = torchaudio.load(audio_path)
+        waveform = waveform.mean(dim=0, keepdim=False)
+
+        if orig_sr != TARGET_SAMPLE_RATE:
+            resampler = torchaudio.transforms.Resample(
+                orig_freq=orig_sr,
+                new_freq=TARGET_SAMPLE_RATE
+            )
+            waveform = resampler(waveform)
+
+        return waveform, TARGET_SAMPLE_RATE
+    except Exception as e:
+        logging.error(f"Audio loading failed: {e}")
+        raise
+
+
+def transcribe_audio(audio_path):
+    """Convert speech to text using Whisper."""
+    try:
+        result = whisper_model.transcribe(audio_path, fp16=False)
+        return result.get('text', '')
+    except Exception as e:
+        logging.error(f"Transcription failed: {e}")
+        return ""
+
+
+def get_predictions(input_data, extractor, is_audio=False):
+    """Generic prediction function for audio/text."""
+    try:
+        if is_audio:
+            pred, emb = extractor.extract(input_data, TARGET_SAMPLE_RATE)
+        else:
+            pred, emb = extractor.extract(input_data)
+
+        return F.softmax(pred, dim=-1)[0].tolist(), emb
+    except Exception as e:
+        logging.error(f"Prediction failed: {e}")
+        return [0.0] * len(LABEL_TO_EMOTION), None
+
+
+def create_emotion_df(probabilities):
+    """Create sorted emotion probability dataframe with percentages."""
+    df = pd.DataFrame({
+        'Emotion': list(LABEL_TO_EMOTION.values()),
+        'Probability': [round(p*100, 2) for p in probabilities]
+    })
+    return df
+
+
+def create_plot(df, title):
+    """Create Plotly bar chart with proper formatting."""
+    fig = px.bar(
+        df,
+        x='Emotion',
+        y='Probability',
+        title=title,
+        color='Emotion',
+        color_discrete_map=emotion_color_map
+    )
+    fig.update_layout(
+        xaxis=dict(tickangle=-45, tickfont=dict(size=12)),
+        yaxis=dict(title='Probability (%)'),
+        margin=dict(l=20, r=20, t=60, b=100),
+        height=400,
+        showlegend=False
+    )
+    return fig
+
+
+def get_top_emotion(probabilities):
+    """Return formatted top emotion with percentage."""
+    max_idx = probabilities.index(max(probabilities))
+    return f"{LABEL_TO_EMOTION[max_idx]} ({max(probabilities)*100:.1f}%)"
+
+
+def process_audio(audio_path):
+    """Main processing pipeline."""
+    try:
+        if not audio_path:
+            empty = create_emotion_df([0]*len(LABEL_TO_EMOTION))
+            return (
+                create_plot(empty, "🎧 Audio Analysis"),
+                "No audio detected",
+                create_plot(empty, "📝 Text Analysis"),
+                create_plot(empty, "🤝 Combined Analysis"),
+                "🔇 Please provide audio input"
+            )
+
+        # Audio processing
+        waveform, sr = load_and_preprocess_audio(audio_path)
+        audio_probs, audio_features = get_predictions(waveform, audio_extractor, is_audio=True)
+        audio_df = create_emotion_df(audio_probs)
+
+        # Text processing
+        text = transcribe_audio(audio_path)
+        text_probs, text_features = get_predictions(text, text_extractor) if text.strip() else [0.0]*len(LABEL_TO_EMOTION)
+        text_df = create_emotion_df(text_probs)
+
+        # Combined results
+        combined_probs = bimodal_model(audio_features, text_features)
+        combined_probs = F.softmax(combined_probs, dim=-1)[0].detach().cpu().numpy().tolist()
+        combined_df = create_emotion_df(combined_probs)
+        top_emotion = get_top_emotion(combined_probs)
+
+        return (
+            create_plot(audio_df, "🎧 Audio Analysis"),
+            f"🗣️ Transcription:\n{text}",
+            create_plot(text_df, "📝 Text Analysis"),
+            create_plot(combined_df, "🤝 Combined Analysis"),
+            f"## 🏆 Dominant Emotion: {top_emotion}"
+        )
+
+    except Exception as e:
+        logging.error(f"Processing failed: {e}")
+        error_df = create_emotion_df([0]*len(LABEL_TO_EMOTION))
+        return (
+            create_plot(error_df, "🎧 Audio Analysis"),
+            "❌ Error processing audio",
+            create_plot(error_df, "📝 Text Analysis"),
+            create_plot(error_df, "🤝 Combined Analysis"),
+            "⚠️ Processing Error"
+        )
+
+
+def create_app():
+    """Build enhanced Gradio interface."""
+    with gr.Blocks(theme=gr.themes.Soft(), title="Emotion Detection from Speech") as demo:
+        gr.Markdown("# 🎙️ Bimodal Emotion Recognition")
+        gr.Markdown("Analyze emotions in speech through both audio characteristics and spoken content")
+
+        with gr.Row():
+            audio_input = gr.Audio(
+                sources=["upload", "microphone"],
+                type="filepath",
+                label="Record or Upload Audio",
+                format="wav",
+                interactive=True
+            )
+
+        with gr.Row():
+            top_emotion = gr.Markdown("## 🏆 Dominant Emotion: Waiting for input...",
+                                      elem_classes="dominant-emotion")
+
+        with gr.Row():
+            with gr.Column():
+                audio_plot = gr.Plot(label="Audio Analysis")
+            with gr.Column():
+                text_plot = gr.Plot(label="Text Analysis")
+            with gr.Column():
+                combined_plot = gr.Plot(label="Combined Analysis")
+
+        transcription = gr.Textbox(
+            label="📜 Transcription Results",
+            placeholder="Transcribed text will appear here...",
+            lines=3,
+            max_lines=6
+        )
+
+        audio_input.change(
+            process_audio,
+            inputs=audio_input,
+            outputs=[audio_plot, transcription, text_plot, combined_plot, top_emotion]
+        )
+
+    return demo
+
+
+def create_authors():
+    df = pd.DataFrame({
+        "Name": ["Author", "Author"]
+    })
+    with gr.Blocks() as demo:
+        gr.Dataframe(df)
+    return demo
+
+
+def create_reqs():
+    """Create requirements tab with formatted data and explanations."""
+    # 1️⃣ Detect file encoding
+    with open('requirements.txt', 'rb') as f:
+        raw_data = f.read()
+        encoding = chardet.detect(raw_data)['encoding']
+
+    # 2️⃣ Parse requirements into library-version pairs
+    def parse_requirements(lines):
+        requirements = []
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue  # Skip empty lines and comments
+            parts = line.split('==')
+            library = parts[0].strip()
+            version = parts[1].strip() if len(parts) > 1 else 'latest'
+            requirements.append((library, version))
+        return requirements
+
+    # 3️⃣ Load and process requirements
+    with open('requirements.txt', 'r', encoding=encoding) as f:
+        requirements = parse_requirements(f.readlines())
+
+    # 4️⃣ Create structured data for display
+    df = pd.DataFrame({
+        "📦 Library": [lib for lib, _ in requirements],
+        "🚀 Recommended Version": [ver for _, ver in requirements]
+    })
+
+    # 5️⃣ Build interactive components
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📦 Dependency Requirements")
+        gr.Markdown("""
+        ## Essential Packages for Operation
+        These are the core libraries and versions needed to run the application successfully:
+        """)
+        gr.Dataframe(
+            df,
+            interactive=True,
+            wrap=True,
+            elem_id="requirements-table"
+        )
+        gr.Markdown("_Note: Versions marked 'latest' can use any compatible version_")
+
+    return demo
+
+
+def create_demo():
+    app = create_app()
+    authors = create_authors()
+    reqs = create_reqs()
+    demo = gr.TabbedInterface(
+        [app, authors, reqs],
+        tab_names=["🎙️ Speech Analysis", "👥 Project Team", "📦 Dependencies"]
+    )
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch()

best_audio_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cf27208d1d99448dd075ae4b499f97aa5fffd0ef7290ebe82555bc09a350469
+size 3174946

best_audio_model_2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed1705e0cf0e5bc7bb1755f7fb09bfc440b4c92c739489d107d5e0e7a29707bc
+size 3174674

best_model_dev_0_5895_epoch_8.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7eeba90564d5c301aa59f487aa59f71923b9d3f293327a99b88c34b71d4226f
+size 17670490

best_text_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e25ae864742da9a8f4ba6b85b6161c503cb47dc6197dd0eb82b5250180a171cf
+size 39340722

check.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Проверка синтетического корпуса MELD-S:
+    • существует ли WAV-файл;
+    • правильные ли размеры аудио- и текст-эмбеддингов;
+    • совпадает ли итоговый размер фич-вектора с ожиданием.
+
+Результат:
+    GOOD / BAD в консоль + CSV bad_synth_meld.csv (если нашли проблемы).
+"""
+
+from __future__ import annotations
+
+import csv
+import logging
+import sys
+import traceback
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Dict, List, Optional
+
+import pandas as pd
+import torch
+import torchaudio
+from tqdm import tqdm
+
+# ----------------------------------------------------------------------
+# >>>>>>>>>     НАСТРОЙКИ ПОЛЬЗОВАТЕЛЯ (проверьте пути!)     <<<<<<<<<<<
+# ----------------------------------------------------------------------
+USER_CONFIG = {
+    # пути к синтетике
+    "synthetic_path": r"E:/MELD_S",
+    "csv_name": "meld_s_train_labels.csv",
+    "wav_subdir": "wavs",
+
+    # модели / чекпойнты такие же, как в вашем config.toml
+    "audio_model_name": "audeering/wav2vec2-large-robust-12-ft-emotion-msp-dim",
+    "audio_ckpt": "best_audio_model_2.pt",
+    "text_model_name": "jinaai/jina-embeddings-v3",
+    "text_ckpt": "best_text_model.pth",
+
+    # общие параметры
+    "device": "cuda" if torch.cuda.is_available() else "cpu",
+    "sample_rate": 16000,
+    "num_emotions": 7,  # anger, disgust, fear, happy, neutral, sad, surprise
+}
+
+# ----------------------------------------------------------------------
+# импорт собственных экстракторов
+# ----------------------------------------------------------------------
+try:
+    from feature_extractor import (
+        PretrainedAudioEmbeddingExtractor,
+        PretrainedTextEmbeddingExtractor,
+    )
+except ModuleNotFoundError:
+    try:
+        # если файл лежит в data_loading/
+        from data_loading.feature_extractor import (
+            PretrainedAudioEmbeddingExtractor,
+            PretrainedTextEmbeddingExtractor,
+        )
+    except ModuleNotFoundError as e:
+        sys.exit(
+            "❌  Не найден feature_extractor.py. "
+            "Убедитесь, что он в PYTHONPATH или лежит рядом со скриптом."
+        )
+
+# ----------------------------------------------------------------------
+# вспомогательные функции
+# ----------------------------------------------------------------------
+def build_audio_cfg() -> SimpleNamespace:
+    """Готовим config-объект для PretrainedAudioEmbeddingExtractor."""
+    return SimpleNamespace(
+        audio_model_name=USER_CONFIG["audio_model_name"],
+        emb_device=USER_CONFIG["device"],
+        audio_pooling="mean",            # как в тренировке
+        emb_normalize=False,
+        max_audio_frames=0,
+        audio_classifier_checkpoint=USER_CONFIG["audio_ckpt"],
+        sample_rate=USER_CONFIG["sample_rate"],
+        wav_length=4,
+    )
+
+
+def build_text_cfg() -> SimpleNamespace:
+    """Config для PretrainedTextEmbeddingExtractor."""
+    return SimpleNamespace(
+        text_model_name=USER_CONFIG["text_model_name"],
+        emb_device=USER_CONFIG["device"],
+        text_pooling="mean",
+        emb_normalize=False,
+        max_tokens=95,
+        text_classifier_checkpoint=USER_CONFIG["text_ckpt"],
+    )
+
+
+def get_dims(audio_extractor, text_extractor) -> Dict[str, int]:
+    """Возвращает фактические размеры эмбеддингов (audio_dim, text_dim)."""
+    sr = USER_CONFIG["sample_rate"]
+    with torch.no_grad():
+        dummy_wav = torch.zeros(1, sr)
+        _, a_emb = audio_extractor.extract(dummy_wav[0], sr)
+        audio_dim = a_emb[0].shape[-1]
+
+        _, t_emb = text_extractor.extract("dummy text")
+        text_dim = t_emb[0].shape[-1]
+
+    return {"audio_dim": audio_dim, "text_dim": text_dim}
+
+
+def check_row(
+    row: pd.Series,
+    feats: Dict[str, object],
+    dims: Dict[str, int],
+    wav_dir: Path,
+) -> Optional[str]:
+    """
+    Возвращает None, если пример корректный, иначе строку-причину.
+    """
+    video = row["video_name"]
+    wav_path = wav_dir / f"{video}.wav"
+    text = row.get("text", "")
+
+    try:
+        if not wav_path.exists():
+            return "file_missing"
+
+        # ---------- аудио ----------
+        wf, sr = torchaudio.load(str(wav_path))
+        if sr != USER_CONFIG["sample_rate"]:
+            wf = torchaudio.transforms.Resample(sr, USER_CONFIG["sample_rate"])(wf)
+
+        a_pred, a_emb = feats["audio"].extract(wf[0], USER_CONFIG["sample_rate"])
+        a_emb = a_emb[0]
+        if a_emb.shape[-1] != dims["audio_dim"]:
+            return f"audio_dim_{a_emb.shape[-1]}"
+
+        # ---------- текст ----------
+        t_pred, t_emb = feats["text"].extract(text)
+        t_emb = t_emb[0]
+        if t_emb.shape[-1] != dims["text_dim"]:
+            return f"text_dim_{t_emb.shape[-1]}"
+
+        # ---------- конкатенация ----------
+        full_vec = torch.cat(
+            [a_emb, t_emb, a_pred[0], t_pred[0]],
+            dim=-1,
+        )
+        expected_all = (
+            dims["audio_dim"]
+            + dims["text_dim"]
+            + 2 * USER_CONFIG["num_emotions"]
+        )
+        if full_vec.shape[-1] != expected_all:
+            return f"concat_dim_{full_vec.shape[-1]}"
+
+    except Exception as e:
+        logging.error(f"{video}: {traceback.format_exc(limit=2)}")
+        return "exception_" + e.__class__.__name__
+
+    return None
+
+
+# ----------------------------------------------------------------------
+# основной скрипт
+# ----------------------------------------------------------------------
+def main() -> None:
+    syn_root = Path(USER_CONFIG["synthetic_path"])
+    csv_path = syn_root / USER_CONFIG["csv_name"]
+    wav_dir = syn_root / USER_CONFIG["wav_subdir"]
+
+    if not csv_path.exists():
+        sys.exit(f"CSV не найден: {csv_path}")
+    if not wav_dir.exists():
+        sys.exit(f"WAV-директория не найдена: {wav_dir}")
+
+    # 1. экстракторы
+    audio_feat = PretrainedAudioEmbeddingExtractor(build_audio_cfg())
+    text_feat = PretrainedTextEmbeddingExtractor(build_text_cfg())
+    feats = {"audio": audio_feat, "text": text_feat}
+
+    # 2. реальные размерности
+    dims = get_dims(audio_feat, text_feat)
+    expected_total = (
+        dims["audio_dim"] + dims["text_dim"] + 2 * USER_CONFIG["num_emotions"]
+    )
+    print(
+        f"Audio dim = {dims['audio_dim']}, "
+        f"Text dim = {dims['text_dim']}, "
+        f"Expected concat = {expected_total}"
+    )
+
+    # 3. правим CSV
+    df = pd.read_csv(csv_path)
+    bad_rows: List[Dict[str, str]] = []
+    good_cnt = 0
+
+    for _, row in tqdm(df.iterrows(), total=len(df), desc="Checking"):
+        reason = check_row(row, feats, dims, wav_dir)
+        if reason:
+            bad_rows.append(
+                {
+                    "video_name": row["video_name"],
+                    "reason": reason,
+                    "wav_path": str(wav_dir / f"{row['video_name']}.wav"),
+                }
+            )
+        else:
+            good_cnt += 1
+
+    # 4. отчёт
+    print("\n========== SUMMARY ==========")
+    print(f"✅ GOOD : {good_cnt}")
+    print(f"❌ BAD  : {len(bad_rows)}")
+
+    if bad_rows:
+        out_csv = Path(__file__).with_name("bad_synth_meld.csv")
+        with open(out_csv, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(
+                f, fieldnames=["video_name", "reason", "wav_path"]
+            )
+            writer.writeheader()
+            writer.writerows(bad_rows)
+        print(f"\nСписок проблемных примеров сохранён: {out_csv.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

config.toml

@@ -0,0 +1,133 @@
+# ---------------------------
+# Настройки корпусов данных
+# ---------------------------
+
+[datasets.meld]
+base_dir = "E:/MELD"
+csv_path = "{base_dir}/meld_{split}_labels.csv"
+wav_dir  = "{base_dir}/wavs/{split}"
+
+[datasets.resd]
+base_dir = "E:/RESD"
+csv_path = "{base_dir}/resd_{split}_labels.csv"
+wav_dir  = "{base_dir}/wavs/{split}"
+
+[synthetic_data]
+use_synthetic_data = false
+synthetic_path = "E:/MELD_S"
+synthetic_ratio = 0.005
+
+# ---------------------------
+# Список модальностей и эмоций
+# ---------------------------
+modalities = ["audio"]
+# emotion_columns = ["neutral", "happy", "sad", "anger", "surprise", "disgust", "fear"]
+emotion_columns = ["anger", "disgust", "fear", "happy", "neutral", "sad", "surprise"]
+
+# ---------------------------
+# DataLoader параметры
+# ---------------------------
+[dataloader]
+num_workers = 0
+shuffle = true
+prepare_only = false
+
+# ---------------------------
+# Аудио
+# ---------------------------
+[audio]
+sample_rate = 16000           # Целевая частота дискретизации
+wav_length = 4                # Целевая длина (в секундах) для аудио
+save_merged_audio = true
+merged_audio_base_path = "saved_merges"
+merged_audio_suffix = "_merged"
+force_remerge = false
+
+# ---------------------------
+# Whisper и текст
+# ---------------------------
+[text]
+# Если "csv", то мы стараемся брать текст из CSV, если там есть
+# (поле text_column). Если нет - тогда Whisper (если нужно).
+source = "csv"
+text_column = "text"
+whisper_model = "base"
+
+# Указываем, где запускать Whisper: "cuda" (GPU) или "cpu"
+whisper_device = "cuda"
+
+# Если для dev/test в CSV нет текста, нужно ли всё же вызывать Whisper?
+use_whisper_for_nontrain_if_no_text = true
+
+# ---------------------------
+# Общие параметры тренировки
+# ---------------------------
+[train.general]
+random_seed = 42         # фиксируем random seed для воспроизводимости (0 = каждый раз разный)
+subset_size = 100         # ограничение на количество примеров (0 = использовать весь датасет)
+merge_probability = 0    # процент склеивания коротких файлов
+batch_size = 8         # размер батча
+num_epochs = 75           # число эпох тренировки
+max_patience = 10        # максимальное число эпох без улучшений (для Early Stopping)
+save_best_model = false
+save_prepared_data = true # сохранять извлеченные признаки (эмбеддинги)
+save_feature_path = './features/' # путь для сохранения эмбеддингов
+search_type = "none" # стратегия поиска: "greedy", "exhaustive" или "none"
+path_to_df_ls = 'Phi-4-mini-instruct_emotions_union.csv'  # путь к датафрейму со смягченными метками - Qwen3-4B_emotions_union или Phi-4-mini-instruct_emotions_union
+smoothing_probability = 0.0 # процент использования смягченных меток
+
+# ---------------------------
+# Параметры модели
+# ---------------------------
+[train.model]
+model_name = "BiFormer"    # название модели (BiGraphFormer, BiFormer, BiGatedGraphFormer, BiGatedFormer, BiMamba, PredictionsFusion, BiFormerWithProb, BiMambaWithProb, BiGraphFormerWithProb, BiGatedGraphFormerWithProb)
+hidden_dim = 256            # размер скрытого состояния
+hidden_dim_gated = 128      # скрытое состояние для gated механизмов
+num_transformer_heads = 16   # количество attention голов в трансформере
+num_graph_heads = 2         # количество голов в граф-механизме
+tr_layer_number = 5         # количество слоев в трансформере
+mamba_d_state = 16          # размер состояния в Mamba
+mamba_ker_size = 6          # размер кернела в Mamba
+mamba_layer_number = 5      # количество слоев Mamba
+positional_encoding = false # использовать ли позиционное кодирование
+dropout = 0.15              # dropout между слоями
+out_features = 256          # размер финальных признаков перед классификацией
+mode = 'mean'               # способ агрегации признаков (например, "mean", "max", и т.д.)
+
+# ---------------------------
+# Параметры оптимизатора
+# ---------------------------
+[train.optimizer]
+optimizer = "adam"        # тип оптимизатора: "adam", "adamw", "lion", "sgd", "rmsprop"
+lr = 1e-4                 # начальная ��корость обучения
+weight_decay = 0.0        # weight decay для регуляризации
+momentum = 0.9            # momentum (используется только в SGD)
+
+# ---------------------------
+# Параметры шедулера
+# ---------------------------
+[train.scheduler]
+scheduler_type = "plateau" # тип шедулера: "none", "plateau", "cosine", "onecycle" ил  и HuggingFace-стиль ("huggingface_linear", "huggingface_cosine" "huggingface_cosine_with_restarts" и т.д.)
+warmup_ratio = 0.1         # отношение количества warmup-итераций к общему числу шагов (0.1 = 10%)
+
+[embeddings]
+# audio_model = "amiriparian/ExHuBERT"  # Hugging Face имя модели для аудио
+audio_model = "audeering/wav2vec2-large-robust-12-ft-emotion-msp-dim"  # Hugging Face имя модели для аудио
+audio_classifier_checkpoint = "best_audio_model_2.pt"
+text_classifier_checkpoint = "best_text_model.pth"
+text_model = "jinaai/jina-embeddings-v3"  # Hugging Face имя модели для текста
+audio_embedding_dim = 256  # размерность аудио-эмбеддинга
+text_embedding_dim = 1024   # размерность текст-эмбеддинга
+emb_normalize = false  # нормализовать ли вектор L2-нормой
+max_tokens = 95         # ограничение на длину текста (токенов) при токенизации
+device = "cuda"          # "cuda" или "cpu", куда грузить модель
+
+# audio_pooling = "mean"        # "mean", "cls", "max", "min", "last", "attention"
+# text_pooling = "cls"          # "mean", "cls", "max", "min", "last", "sum", "attention"
+
+[textgen]
+# model_name = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"  # deepseek-ai/deepseek-llm-1.3b-base или любая другая модель
+# model_name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"  # deepseek-ai/deepseek-llm-1.3b-base или любая другая модель
+max_new_tokens = 50
+temperature = 1.0
+top_p = 0.95

data_loading/dataset_multimodal.py

@@ -0,0 +1,898 @@
+# -*- coding: utf-8 -*-
+
+import os
+import random
+import logging
+import torch
+import torchaudio
+import whisper
+import numpy as np
+import pandas as pd
+from torch.utils.data import Dataset
+import pickle
+from tqdm import tqdm
+# from data_loading.feature_extractor import PretrainedAudioEmbeddingExtractor, PretrainedTextEmbeddingExtractor
+
+class DatasetMultiModalWithPretrainedExtractors(Dataset):
+    """
+    Мультимодальный датасет для аудио, текста и эмоций (он‑the‑fly версия).
+
+    При каждом вызове __getitem__:
+      - Загружает WAV по video_name из CSV.
+      - Для обучающей выборки (split="train"):
+            Если аудио короче target_samples, проверяем, выбрали ли мы этот файл для склейки
+            (по merge_probability). Если да – выполняется "chain merge":
+            выбирается один или несколько дополнительных файлов того же класса, даже если один кандидат длиннее,
+            и итоговое аудио затем обрезается до точной длины.
+      - Если итоговое аудио всё ещё меньше target_samples, выполняется паддинг нулями.
+      - Текст выбирается так:
+            • Если аудио было merged (склеено) – вызывается Whisper для получения нового текста.
+            • Если merge не происходило и CSV-текст не пуст – используется CSV-текст.
+            • Если CSV-текст пустой – для train (или, при условии, для dev/test) вызывается Whisper.
+      - Возвращает словарь { "audio": waveform, "label": label_vector, "text": text_final }.
+    """
+
+    def __init__(
+        self,
+        csv_path,
+        wav_dir,
+        emotion_columns,
+        config,
+        split,
+        audio_feature_extractor,
+        text_feature_extractor,
+        whisper_model,
+        dataset_name
+    ):
+        """
+        :param csv_path: Путь к CSV-файлу (с колонками video_name, emotion_columns, возможно text).
+        :param wav_dir: Папка с аудиофайлами (имя файла: video_name.wav).
+        :param emotion_columns: Список колонок эмоций, например ["neutral", "happy", "sad", ...].
+        :param split: "train", "dev" или "test".
+        :param audio_feature_extractor: Экстрактор аудио признаков
+        :param text_feature_extractor: Экстрактор текстовых признаков
+        :param sample_rate: Целевая частота дискретизации (например, 16000).
+        :param wav_length: Целевая длина аудио в секундах.
+        :param whisper_model: Mодель Whisper ("tiny", "base", "small", ...).
+        :param max_text_tokens: (Не используется) – ограничение на число токенов.
+        :param text_column: Название колонки с текстом в CSV.
+        :param use_whisper_for_nontrain_if_no_text: Если True, для dev/test при отсутствии CSV-текста вызывается Whisper.
+        :param whisper_device: "cuda" или "cpu" – устройство для модели Whisper.
+        :param subset_size: Если > 0, используется только первые N записей из CSV (для отладки).
+        :param merge_probability: Процент (0..1) от всего числа файлов, которые будут склеиваться, если они короче.
+        :param dataset_name: Название корпуса
+        """
+        super().__init__()
+        self.split = split
+        self.sample_rate = config.sample_rate
+        self.target_samples = int(config.wav_length * self.sample_rate)
+        self.emotion_columns = emotion_columns
+        self.whisper_model = whisper_model
+        self.text_column =  config.text_column
+        self.use_whisper_for_nontrain_if_no_text =  config.use_whisper_for_nontrain_if_no_text
+        self.whisper_device = config.whisper_device
+        self.merge_probability = config.merge_probability
+        self.audio_feature_extractor = audio_feature_extractor
+        self.text_feature_extractor = text_feature_extractor
+        self.subset_size    = config.subset_size
+        self.save_prepared_data = config.save_prepared_data
+        self.seed = config.random_seed
+        self.dataset_name = dataset_name
+        self.save_feature_path = config.save_feature_path
+        self.use_synthetic_data = config.use_synthetic_data
+        self.synthetic_path = config.synthetic_path
+        self.synthetic_ratio = config.synthetic_ratio
+
+        # Загружаем CSV
+        if not os.path.exists(csv_path):
+            raise ValueError(f"Ошибка: файл CSV не найден: {csv_path}")
+        df = pd.read_csv(csv_path)
+        if self.subset_size > 0:
+            df = df.head(self.subset_size)
+            logging.info(f"[DatasetMultiModal] Используем только первые {len(df)} записей (subset_size={self.subset_size}).")
+
+        #копия для сохранения текста Wisper
+        self.original_df = df.copy()
+        self.whisper_csv_update_log = []
+
+        # Проверяем наличие всех колонок эмоций
+        missing = [c for c in emotion_columns if c not in df.columns]
+        if missing:
+            raise ValueError(f"В CSV отсутствуют необходимые колонки эмоций: {missing}")
+
+        # Проверяем существование папки с аудио
+        if not os.path.exists(wav_dir):
+            raise ValueError(f"Ошибка: директория с аудио {wav_dir} не существует!")
+        self.wav_dir = wav_dir
+
+        # Собираем список строк: для каждой записи получаем путь к аудио, label и CSV-текст (если есть)
+        self.rows = []
+        for i, rowi in df.iterrows():
+            audio_path = os.path.join(wav_dir, f"{rowi['video_name']}.wav")
+            if not os.path.exists(audio_path):
+                continue
+            # Определяем доминирующую эмоцию (максимальное значение)
+            # print(self.emotion_columns)
+            emotion_values = rowi[self.emotion_columns].values.astype(float)
+            max_idx = np.argmax(emotion_values)
+            emotion_label = self.emotion_columns[max_idx]
+
+            # Извлекаем текст из CSV (если есть)
+            csv_text = ""
+            if self.text_column in rowi and isinstance(rowi[self.text_column], str):
+                csv_text = rowi[self.text_column]
+
+            self.rows.append({
+                "audio_path": audio_path,
+                "label": emotion_label,
+                "csv_text": csv_text
+            })
+
+        if self.use_synthetic_data and self.split == "train" and self.dataset_name.lower() == "meld":
+            logging.info(f"🧪 Включена синтетика для датасета '{self.dataset_name}' — добавляем примеры из: {self.synthetic_path}")
+            self._add_synthetic_data(self.synthetic_ratio)
+
+        # Создаем карту для поиска файлов по эмоции
+        self.audio_class_map = {entry["audio_path"]: entry["label"] for entry in self.rows}
+
+        logging.info("📊 Анализ распределения файлов по эмоциям:")
+        emotion_counts = {emotion: 0 for emotion in set(self.audio_class_map.values())}
+        for path, emotion in self.audio_class_map.items():
+            emotion_counts[emotion] += 1
+        for emotion, count in emotion_counts.items():
+            logging.info(f"🎭 Эмоция '{emotion}': {count} файлов.")
+
+        logging.info(f"[DatasetMultiModal] Сплит={split}, всего строк: {len(self.rows)}")
+
+        # === Процентное семплирование ===
+        total_files = len(self.rows)
+        num_to_merge = int(total_files * self.merge_probability)
+
+        # <<< NEW: Кешируем длины (eq_len) для всех файлов >>>
+        self.path_info = {}
+        for row in self.rows:
+            p = row["audio_path"]
+            try:
+                info = torchaudio.info(p)
+                length = info.num_frames
+                sr_ = info.sample_rate
+                # переводим длину в "эквивалент self.sample_rate"
+                if sr_ != self.sample_rate:
+                    ratio = sr_ / self.sample_rate
+                    eq_len = int(length / ratio)
+                else:
+                    eq_len = length
+                self.path_info[p] = eq_len
+            except Exception as e:
+                logging.warning(f"⚠️ Ошибка чтения {p}: {e}")
+                self.path_info[p] = 0  # Если не смогли прочитать, ставим 0
+
+        # Определим, какие файлы "короткие" (могут нуждаться в склейке) - используем кэш вместо старого _is_too_short
+        self.mergable_files = [
+            row["audio_path"]  # вместо целого dict берём строку
+            for row in self.rows
+            if self._is_too_short_cached(row["audio_path"])  # <<< теперь тут используем новую функцию
+        ]
+        short_count = len(self.mergable_files)
+
+        # Если коротких файлов больше нужного числа, выберем случайные. Иначе все короткие.
+        if short_count > num_to_merge:
+            self.files_to_merge = set(random.sample(self.mergable_files, num_to_merge))
+        else:
+            self.files_to_merge = set(self.mergable_files)
+
+        logging.info(f"🔗 Всего файлов: {total_files}, нужно склеить: {num_to_merge} ({self.merge_probability*100:.0f}%)")
+        logging.info(f"🔗 Коротких файлов: {short_count}, выбрано для склейки: {len(self.files_to_merge)}")
+
+        if self.save_prepared_data:
+            self.meta = []
+
+            if self.use_synthetic_data:
+                meta_filename = '{}_{}_seed_{}_subset_size_{}_audio_model_{}_feature_norm_{}_synthetic_true_pct_{}_pred.pickle'.format(
+                    self.dataset_name,
+                    self.split,
+                    config.audio_classifier_checkpoint[-4:-3],
+                    self.seed,
+                    self.subset_size,
+                    config.emb_normalize,
+                    int(self.synthetic_ratio * 100)
+                )
+
+            else:
+                meta_filename = '{}_{}_seed_{}_subset_size_{}_audio_model_{}_feature_norm_{}_merge_prob_{}_pred.pickle'.format(
+                    self.dataset_name,
+                    self.split,
+                    config.audio_classifier_checkpoint[-4:-3],
+                    self.seed,
+                    self.subset_size,
+                    config.emb_normalize,
+                    self.merge_probability
+                )
+
+            pickle_path = os.path.join(self.save_feature_path, meta_filename)
+            self.load_data(pickle_path)
+
+            if not self.meta:
+                self.prepare_data()
+                os.makedirs(self.save_feature_path, exist_ok=True)
+                self.save_data(pickle_path)
+
+    def save_data(self, filename):
+        with open(filename, 'wb') as handle:
+            pickle.dump(self.meta, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def load_data(self, filename):
+        if os.path.exists(filename):
+            with open(filename, 'rb') as handle:
+                self.meta = pickle.load(handle)
+        else:
+            self.meta = []
+
+    def _is_too_short(self, audio_path):
+        """
+        (Оригинальная) Проверяем, является ли файл короче target_samples.
+        Использует torchaudio.info(audio_path).
+        Но теперь этот метод не используется, поскольку мы кешируем длины.
+        """
+        try:
+            info = torchaudio.info(audio_path)
+            length = info.num_frames
+            sr_ = info.sample_rate
+            # переводим длину в "эквивалент self.sample_rate"
+            if sr_ != self.sample_rate:
+                ratio = sr_ / self.sample_rate
+                eq_len = int(length / ratio)
+            else:
+                eq_len = length
+            return eq_len < self.target_samples
+        except Exception as e:
+            logging.warning(f"Ошибка _is_too_short({audio_path}): {e}")
+            return False
+
+    def _is_too_short_cached(self, audio_path):
+        """
+        (Новая) Проверяем, является ли файл короче target_samples, используя закешированную длину в self.path_info.
+        """
+        eq_len = self.path_info.get(audio_path, 0)
+        return eq_len < self.target_samples
+
+    def __len__(self):
+        if self.save_prepared_data:
+            return len(self.meta)
+        else:
+            return len(self.rows)
+
+    def get_data(self, row):
+        audio_path = row["audio_path"]
+        label_name = row["label"]
+        csv_text = row["csv_text"]
+
+        # Преобразуем label в one-hot вектор
+        label_vec = self.emotion_to_vector(label_name)
+
+        # Шаг 1. Загружаем аудио
+        waveform, sr = self.load_audio(audio_path)
+        if waveform is None:
+            return None
+
+        orig_len = waveform.shape[1]
+        logging.debug(f"Исходная длина {os.path.basename(audio_path)}: {orig_len/sr:.2f} сек")
+
+        was_merged = False
+        merged_texts = [csv_text]  # Тексты исходного файла + добавленных
+
+        # Шаг 2. Для train, если аудио короче target_samples, проверяем:
+        #        попал ли данный row в files_to_merge?
+        if self.split == "train" and row["audio_path"] in self.files_to_merge:
+            # chain merge
+            current_length = orig_len
+            used_candidates = set()
+
+            while current_length < self.target_samples:
+                needed = self.target_samples - current_length
+                candidate = self.get_suitable_audio(label_name, exclude_path=audio_path, min_needed=needed, top_k=10)
+                if candidate is None or candidate in used_candidates:
+                    break
+                used_candidates.add(candidate)
+                add_wf, add_sr = self.load_audio(candidate)
+                if add_wf is None:
+                    break
+                logging.debug(f"Склейка: добавляем {os.path.basename(candidate)} (необходимых сэмплов: {needed})")
+                waveform = torch.cat((waveform, add_wf), dim=1)
+                current_length = waveform.shape[1]
+                was_merged = True
+
+                # Получаем текст второго файла (если есть в CSV)
+                add_csv_text = next((r["csv_text"] for r in self.rows if r["audio_path"] == candidate), "")
+                merged_texts.append(add_csv_text)
+
+                logging.debug(f"📜 Текст первого файла: {csv_text}")
+                logging.debug(f"📜 Текст добавленного файла: {add_csv_text}")
+        else:
+            # Если файл не в списке "должны склеить" или сплит не train, пропускаем chain-merge
+            logging.debug("Файл не выбран для склейки (или не train), пропускаем chain merge.")
+
+        if was_merged:
+            logging.debug("📝 Текст: аудио было merged – вызываем Whisper.")
+            text_final = self.run_whisper(waveform)
+            logging.debug(f"🆕 Whisper предсказал: {text_final}")
+
+            merge_components = [os.path.splitext(os.path.basename(audio_path))[0]]
+            merge_components += [os.path.splitext(os.path.basename(p))[0] for p in used_candidates]
+
+            self.whisper_csv_update_log.append({
+                "video_name": os.path.splitext(os.path.basename(audio_path))[0],
+                "text_new": text_final,
+                "text_old": csv_text,
+                "was_merged": True,
+                "merge_components": merge_components
+            })
+
+        else:
+            if csv_text.strip():
+                logging.debug("Текст: используем CSV-текст (не пуст).")
+                text_final = csv_text
+            else:
+                if self.split == "train" or self.use_whisper_for_nontrain_if_no_text:
+                    logging.debug("Текст: CSV пустой – вызываем Whisper.")
+                    text_final = self.run_whisper(waveform)
+                else:
+                    logging.debug("Текст: CSV пустой и не вызываем Whisper для dev/test.")
+                    text_final = ""
+
+        audio_pred, audion_emb = self.audio_feature_extractor.extract(waveform[0], self.sample_rate)
+        text_pred, text_emb = self.text_feature_extractor.extract(text_final)
+
+        return {
+            "audio_path": os.path.basename(audio_path),
+            "audio": audion_emb[0],
+            "label": label_vec,
+            "text": text_emb[0],
+            "audio_pred": audio_pred[0],
+            "text_pred": text_pred[0]
+        }
+
+    def prepare_data(self):
+        """
+        Загружает и обрабатывает один элемент датасета,
+        сохраняет эмбеддинги и обновлённый текст (если было склеено).
+        """
+        for idx, row in enumerate(tqdm(self.rows)):
+            curr_dict = self.get_data(row)
+            if curr_dict is not None:
+                self.meta.append(curr_dict)
+
+        # === Сохраняем CSV с обновлёнными текстами (только если был merge) ===
+        if self.whisper_csv_update_log:
+            df_log = pd.DataFrame(self.whisper_csv_update_log)
+
+            # Копия исходного CSV
+            df_out = self.original_df.copy()
+
+            # Мержим по video_name
+            df_out = df_out.merge(df_log, on="video_name", how="left")
+
+            # Обновляем текст: заменяем только если Whisper сгенерировал
+            df_out["text_final"] = df_out["text_new"].combine_first(df_out["text"])
+            df_out["text_old"] = df_out["text"]
+            df_out["text"] = df_out["text_final"]
+            df_out["was_merged"] = df_out["was_merged"].fillna(False).astype(bool)
+
+            # Преобразуем merge_components в строку
+            df_out["merge_components"] = df_out["merge_components"].apply(
+                lambda x: ";".join(x) if isinstance(x, list) else ""
+            )
+
+            # Чистим временные колонки
+            df_out = df_out.drop(columns=["text_new", "text_final"])
+
+            # Сохраняем как CSV
+            output_path = os.path.join(self.save_feature_path, f"{self.dataset_name}_{self.split}_merged_whisper_{self.merge_probability *100}.csv")
+            os.makedirs(self.save_feature_path, exist_ok=True)
+            df_out.to_csv(output_path, index=False, encoding="utf-8")
+            logging.info(f"📄 Обновлённый merged CSV сохранён: {output_path}")
+
+    def __getitem__(self, index):
+        if self.save_prepared_data:
+            return self.meta[index]
+        else:
+            return self.get_data(self.rows[index])
+
+    def load_audio(self, path):
+        """
+        Загружает аудио по указанному пути и ресэмплирует его до self.sample_rate, если необходимо.
+        """
+        if not os.path.exists(path):
+            logging.warning(f"Файл отсутствует: {path}")
+            return None, None
+        try:
+            wf, sr = torchaudio.load(path)
+            if sr != self.sample_rate:
+                resampler = torchaudio.transforms.Resample(sr, self.sample_rate)
+                wf = resampler(wf)
+                sr = self.sample_rate
+            return wf, sr
+        except Exception as e:
+            logging.error(f"Ошибка загрузки {path}: {e}")
+            return None, None
+
+    def get_suitable_audio(self, label_name, exclude_path, min_needed, top_k=5):
+        """
+        Ищет аудиофайл с той же эмоцией.
+        1) Если есть файлы >= min_needed, выбираем случайно из них.
+        2) Если таких нет, берём топ-K самых длинных, потом из них берём случайный.
+        """
+
+        candidates = [p for p, lbl in self.audio_class_map.items()
+                    if lbl == label_name and p != exclude_path]
+        logging.debug(f"🔍 Найдено {len(candidates)} кандидатов для эмоции '{label_name}'")
+
+        # Сохраним: (eq_len, path) для всех кандидатов, но БЕЗ повторного чтения torchaudio.info
+        all_info = []
+        for path in candidates:
+            # <<< NEW: вместо info = torchaudio.info(path) ...
+            eq_len = self.path_info.get(path, 0)  # Получаем из кэша
+            all_info.append((eq_len, path))
+
+        valid = [(l, p) for l, p in all_info if l >= min_needed]
+        logging.debug(f"✅ Подходящих (>= {min_needed}): {len(valid)} (из {len(all_info)})")
+
+        if valid:
+            # Если есть идеальные — берём случайно из них
+            random.shuffle(valid)
+            chosen = random.choice(valid)[1]
+            return chosen
+        else:
+            # 2) Если идеальных нет — берём топ-K по длине
+            sorted_by_len = sorted(all_info, key=lambda x: x[0], reverse=True)
+            top_k_list = sorted_by_len[:top_k]
+            if not top_k_list:
+                logging.debug("Нет доступных кандидатов вообще.")
+                return None  # вообще нет кандидатов
+
+            random.shuffle(top_k_list)
+            chosen = top_k_list[0][1]
+            logging.info(f"Из топ-{top_k} выбран кандидат: {chosen}")
+            return chosen
+
+    def run_whisper(self, waveform):
+        """
+        Вызывает Whisper на аудиосигнале и возвращает полный текст (без ограничения по количеству слов).
+        """
+        arr = waveform.squeeze().cpu().numpy()
+        try:
+            with torch.no_grad():
+                result = self.whisper_model.transcribe(arr, fp16=False)
+            text = result["text"].strip()
+            return text
+        except Exception as e:
+            logging.error(f"Whisper ошибка: {e}")
+            return ""
+
+    def _add_synthetic_data(self, synthetic_ratio):
+        """
+        Добавляет synthetic_ratio (0..1) от количества доступных синтетических файлов на каждую эмоцию.
+        """
+        if not self.synthetic_path:
+            logging.warning("⚠ Путь к синтетическим данным не указан.")
+            return
+
+        random.seed(self.seed)
+
+        synth_csv_path = os.path.join(self.synthetic_path, "meld_s_train_labels.csv")
+        synth_wav_dir = os.path.join(self.synthetic_path, "wavs")
+
+        if not (os.path.exists(synth_csv_path) and os.path.exists(synth_wav_dir)):
+            logging.warning("⚠ Синтетические данные не найдены.")
+            return
+
+        df_synth = pd.read_csv(synth_csv_path)
+        rows_by_label = {emotion: [] for emotion in self.emotion_columns}
+
+        for _, row in df_synth.iterrows():
+            audio_path = os.path.join(synth_wav_dir, f"{row['video_name']}.wav")
+            if not os.path.exists(audio_path):
+                continue
+            emotion_values = row[self.emotion_columns].values.astype(float)
+            max_idx = np.argmax(emotion_values)
+            label = self.emotion_columns[max_idx]
+            csv_text = row[self.text_column] if self.text_column in row and isinstance(row[self.text_column], str) else ""
+            rows_by_label[label].append({
+                "audio_path": audio_path,
+                "label": label,
+                "csv_text": csv_text
+            })
+
+        added = 0
+        for label in self.emotion_columns:
+            candidates = rows_by_label[label]
+            if not candidates:
+                continue
+            count_synth = int(len(candidates) * synthetic_ratio)
+            if count_synth <= 0:
+                continue
+            selected = random.sample(candidates, count_synth)
+            self.rows.extend(selected)
+            added += len(selected)
+            logging.info(f"➕ Добавлено {len(selected)} синтетических примеров для эмоции '{label}'")
+
+        logging.info(f"📦 Всего добавлено {added} синтетических примеров из MELD_S")
+
+    def emotion_to_vector(self, label_name):
+        """
+        Преобразует название эмоции в one-hot вектор (torch.tensor).
+        """
+        v = np.zeros(len(self.emotion_columns), dtype=np.float32)
+        if label_name in self.emotion_columns:
+            idx = self.emotion_columns.index(label_name)
+            v[idx] = 1.0
+        return torch.tensor(v, dtype=torch.float32)
+
+class DatasetMultiModal(Dataset):
+    """
+    Мультимодальный датасет для аудио, текста и эмоций (он‑the‑fly версия).
+
+    При каждом вызове __getitem__:
+      - Загружает WAV по video_name из CSV.
+      - Для обучающей выборки (split="train"):
+            Если аудио короче target_samples, проверяем, выбрали ли мы этот файл для склейки
+            (по merge_probability). Если да – выполняется "chain merge":
+            выбирается один или несколько дополнительных файлов того же класса, даже если один кандидат длиннее,
+            и итоговое аудио затем обрезается до точной длины.
+      - Если итоговое аудио всё ещё меньше target_samples, выполняется паддинг нулями.
+      - Текст выбирается так:
+            • Если аудио было merged (склеено) – вызывается Whisper для получения нового текста.
+            • Если merge не происходило и CSV-текст не пуст – используется CSV-текст.
+            • Если CSV-текст пустой – для train (или, при условии, для dev/test) вызывается Whisper.
+      - Возвращает словарь { "audio": waveform, "label": label_vector, "text": text_final }.
+    """
+
+    def __init__(
+        self,
+        csv_path,
+        wav_dir,
+        emotion_columns,
+        split="train",
+        sample_rate=16000,
+        wav_length=4,
+        whisper_model="tiny",
+        text_column="text",
+        use_whisper_for_nontrain_if_no_text=True,
+        whisper_device="cuda",
+        subset_size=0,
+        merge_probability=1.0  # <-- Новый параметр: доля от ОБЩЕГО числа файлов
+    ):
+        """
+        :param csv_path: Путь к CSV-файлу (с колонками video_name, emotion_columns, возможно text).
+        :param wav_dir: Папка с аудиофайлами (имя файла: video_name.wav).
+        :param emotion_columns: Список колонок эмоций, например ["neutral", "happy", "sad", ...].
+        :param split: "train", "dev" или "test".
+        :param sample_rate: Целевая частота дискретизации (например, 16000).
+        :param wav_length: Целевая длина аудио в секундах.
+        :param whisper_model: Название модели Whisper ("tiny", "base", "small", ...).
+        :param max_text_tokens: (Не используется) – ограничение на число токенов.
+        :param text_column: Название колонки с текстом в CSV.
+        :param use_whisper_for_nontrain_if_no_text: Если True, для dev/test при отсутствии CSV-текста вызывается Whisper.
+        :param whisper_device: "cuda" или "cpu" – устройство для модели Whisper.
+        :param subset_size: Если > 0, используется только первые N записей из CSV (для отладки).
+        :param merge_probability: Процент (0..1) от всего числа файлов, которые будут склеиваться, если они короче.
+        """
+        super().__init__()
+        self.split = split
+        self.sample_rate = sample_rate
+        self.target_samples = int(wav_length * sample_rate)
+        self.emotion_columns = emotion_columns
+        self.whisper_model_name = whisper_model
+        self.text_column = text_column
+        self.use_whisper_for_nontrain_if_no_text = use_whisper_for_nontrain_if_no_text
+        self.whisper_device = whisper_device
+        self.merge_probability = merge_probability
+
+        # Загружаем CSV
+        if not os.path.exists(csv_path):
+            raise ValueError(f"Ошибка: файл CSV не найден: {csv_path}")
+        df = pd.read_csv(csv_path)
+        if subset_size > 0:
+            df = df.head(subset_size)
+            logging.info(f"[DatasetMultiModal] Используем только первые {len(df)} записей (subset_size={subset_size}).")
+
+        # Проверяем наличие всех колонок эмоций
+        missing = [c for c in emotion_columns if c not in df.columns]
+        if missing:
+            raise ValueError(f"В CSV отсутствуют необходимые колонки эмоций: {missing}")
+
+        # Проверяем существование папки с аудио
+        if not os.path.exists(wav_dir):
+            raise ValueError(f"Ошибка: директория с аудио {wav_dir} не существует!")
+        self.wav_dir = wav_dir
+
+        # Собираем список строк: для каждой записи получаем путь к аудио, label и CSV-текст (если есть)
+        self.rows = []
+        for i, rowi in df.iterrows():
+            audio_path = os.path.join(wav_dir, f"{rowi['video_name']}.wav")
+            if not os.path.exists(audio_path):
+                continue
+            # Определяем доминирующую эмоцию (максимальное значение)
+            emotion_values = rowi[self.emotion_columns].values.astype(float)
+            max_idx = np.argmax(emotion_values)
+            emotion_label = self.emotion_columns[max_idx]
+
+            # Извлекаем текст из CSV (если есть)
+            csv_text = ""
+            if self.text_column in rowi and isinstance(rowi[self.text_column], str):
+                csv_text = rowi[self.text_column]
+
+            self.rows.append({
+                "audio_path": audio_path,
+                "label": emotion_label,
+                "csv_text": csv_text
+            })
+
+        # Создаем карту для поиска файлов по эмоции
+        self.audio_class_map = {entry["audio_path"]: entry["label"] for entry in self.rows}
+
+        logging.info("📊 Анализ распределения файлов по эмоциям:")
+        emotion_counts = {emotion: 0 for emotion in set(self.audio_class_map.values())}
+        for path, emotion in self.audio_class_map.items():
+            emotion_counts[emotion] += 1
+        for emotion, count in emotion_counts.items():
+            logging.info(f"🎭 Эмоция '{emotion}': {count} файлов.")
+
+        logging.info(f"[DatasetMultiModal] Сплит={split}, всего строк: {len(self.rows)}")
+
+        # === Процентное семплирование ===
+        total_files = len(self.rows)
+        num_to_merge = int(total_files * self.merge_probability)
+
+        # <<< NEW: Кешируем длины (eq_len) для всех файлов >>>
+        self.path_info = {}
+        for row in self.rows:
+            p = row["audio_path"]
+            try:
+                info = torchaudio.info(p)
+                length = info.num_frames
+                sr_ = info.sample_rate
+                # переводим длину в "эквивалент self.sample_rate"
+                if sr_ != self.sample_rate:
+                    ratio = sr_ / self.sample_rate
+                    eq_len = int(length / ratio)
+                else:
+                    eq_len = length
+                self.path_info[p] = eq_len
+            except Exception as e:
+                logging.warning(f"⚠️ Ошибка чтения {p}: {e}")
+                self.path_info[p] = 0  # Если не смогли прочитать, ставим 0
+
+        # Определим, какие файлы "короткие" (могут нуждаться в склейке) - используем кэш вместо старого _is_too_short
+        self.mergable_files = [
+            row["audio_path"]  # вместо целого dict берём строку
+            for row in self.rows
+            if self._is_too_short_cached(row["audio_path"])  # <<< теперь тут используем новую функцию
+        ]
+        short_count = len(self.mergable_files)
+
+        # Если коротких файлов больше нужного числа, выберем случайные. Иначе все короткие.
+        if short_count > num_to_merge:
+            self.files_to_merge = set(random.sample(self.mergable_files, num_to_merge))
+        else:
+            self.files_to_merge = set(self.mergable_files)
+
+        logging.info(f"🔗 Всего файлов: {total_files}, нужно склеить: {num_to_merge} ({self.merge_probability*100:.0f}%)")
+        logging.info(f"🔗 Коротких файлов: {short_count}, выбрано для склейки: {len(self.files_to_merge)}")
+
+        # Инициализируем Whisper-модель один раз
+        logging.info(f"Инициализация Whisper: модель={whisper_model}, устройство={whisper_device}")
+        self.whisper_model = whisper.load_model(whisper_model, device=whisper_device).eval()
+        # print(f"📦 Whisper работает на устройстве: {self.whisper_model.device}")
+
+    def _is_too_short(self, audio_path):
+        """
+        (Оригинальная) Проверяем, является ли файл короче target_samples.
+        Использует torchaudio.info(audio_path).
+        Но теперь этот метод не используется, поскольку мы кешируем длины.
+        """
+        try:
+            info = torchaudio.info(audio_path)
+            length = info.num_frames
+            sr_ = info.sample_rate
+            # переводим длину в "эквивалент self.sample_rate"
+            if sr_ != self.sample_rate:
+                ratio = sr_ / self.sample_rate
+                eq_len = int(length / ratio)
+            else:
+                eq_len = length
+            return eq_len < self.target_samples
+        except Exception as e:
+            logging.warning(f"Ошибка _is_too_short({audio_path}): {e}")
+            return False
+
+    def _is_too_short_cached(self, audio_path):
+        """
+        (Новая) Проверяем, является ли файл короче target_samples, используя закешированную длину в self.path_info.
+        """
+        eq_len = self.path_info.get(audio_path, 0)
+        return eq_len < self.target_samples
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self, index):
+        """
+        Загружает и обрабатывает один элемент датасета (он‑the‑fly).
+        """
+        row = self.rows[index]
+        audio_path = row["audio_path"]
+        label_name = row["label"]
+        csv_text = row["csv_text"]
+
+        # Преобразуем label в one-hot вектор
+        label_vec = self.emotion_to_vector(label_name)
+
+        # Шаг 1. Загружаем аудио
+        waveform, sr = self.load_audio(audio_path)
+        if waveform is None:
+            return None
+
+        orig_len = waveform.shape[1]
+        logging.debug(f"Исходная длина {os.path.basename(audio_path)}: {orig_len/sr:.2f} сек")
+
+        was_merged = False
+        merged_texts = [csv_text]  # Тексты исходного файла + добавленных
+
+        # Шаг 2. Для train, если аудио короче target_samples, проверяем:
+        #        попал ли данный row в files_to_merge?
+        if self.split == "train" and row["audio_path"] in self.files_to_merge:
+            # chain merge
+            current_length = orig_len
+            used_candidates = set()
+
+            while current_length < self.target_samples:
+                needed = self.target_samples - current_length
+                candidate = self.get_suitable_audio(label_name, exclude_path=audio_path, min_needed=needed, top_k=10)
+                if candidate is None or candidate in used_candidates:
+                    break
+                used_candidates.add(candidate)
+                add_wf, add_sr = self.load_audio(candidate)
+                if add_wf is None:
+                    break
+                logging.debug(f"Склейка: добавляем {os.path.basename(candidate)} (необходимых сэмплов: {needed})")
+                waveform = torch.cat((waveform, add_wf), dim=1)
+                current_length = waveform.shape[1]
+                was_merged = True
+
+                # Получаем текст второго файла (если есть в CSV)
+                add_csv_text = next((r["csv_text"] for r in self.rows if r["audio_path"] == candidate), "")
+                merged_texts.append(add_csv_text)
+
+                logging.debug(f"📜 Текст первого файла: {csv_text}")
+                logging.debug(f"📜 Текст добавленного файла: {add_csv_text}")
+        else:
+            # Если файл не в списке "должны склеить" или сплит не train, пропускаем chain-merge
+            logging.debug("Файл не выбран для склейки (или не train), пропускаем chain merge.")
+
+        # Шаг 3. Если итоговая длина меньше target_samples, паддинг нулями
+        curr_len = waveform.shape[1]
+        if curr_len < self.target_samples:
+            pad_size = self.target_samples - curr_len
+            logging.debug(f"Паддинг {os.path.basename(audio_path)}: +{pad_size} сэмплов")
+            waveform = torch.nn.functional.pad(waveform, (0, pad_size))
+
+        # Шаг 4. Обрезаем аудио до target_samples (если вышло больше)
+        waveform = waveform[:, :self.target_samples]
+        logging.debug(f"Финальная длина {os.path.basename(audio_path)}: {waveform.shape[1]/sr:.2f} сек; was_merged={was_merged}")
+
+        # Шаг 5. Получаем текст
+        if was_merged:
+            logging.debug("📝 Текст: аудио было merged – вызываем Whisper.")
+            text_final = self.run_whisper(waveform)
+            logging.debug(f"🆕 Whisper предсказал: {text_final}")
+        else:
+            if csv_text.strip():
+                logging.debug("Текст: используем CSV-текст (не пуст).")
+                text_final = csv_text
+            else:
+                if self.split == "train" or self.use_whisper_for_nontrain_if_no_text:
+                    logging.debug("Текст: CSV пустой – вызываем Whisper.")
+                    text_final = self.run_whisper(waveform)
+                else:
+                    logging.debug("Текст: CSV пустой и не вызываем Whisper для dev/test.")
+                    text_final = ""
+
+        return {
+            "audio_path": os.path.basename(audio_path), # new
+            "audio": waveform,
+            "label": label_vec,
+            "text": text_final
+        }
+
+    def load_audio(self, path):
+        """
+        Загружает аудио по указанному пути и ресэмплирует его до self.sample_rate, если необходимо.
+        """
+        if not os.path.exists(path):
+            logging.warning(f"Файл отсутствует: {path}")
+            return None, None
+        try:
+            wf, sr = torchaudio.load(path)
+            if sr != self.sample_rate:
+                resampler = torchaudio.transforms.Resample(sr, self.sample_rate)
+                wf = resampler(wf)
+                sr = self.sample_rate
+            return wf, sr
+        except Exception as e:
+            logging.error(f"Ошибка загрузки {path}: {e}")
+            return None, None
+
+    def get_suitable_audio(self, label_name, exclude_path, min_needed, top_k=5):
+        """
+        Ищет аудиофайл с той же эмоцией.
+        1) Если есть файлы >= min_needed, выбираем случайно из них.
+        2) Если таких нет, берём топ-K самых длинных, потом из них берём случайный.
+        """
+
+        candidates = [p for p, lbl in self.audio_class_map.items()
+                    if lbl == label_name and p != exclude_path]
+        logging.debug(f"🔍 Найдено {len(candidates)} кандидатов для эмоции '{label_name}'")
+
+        # Сохраним: (eq_len, path) для всех кандидатов, но БЕЗ повторного чтения torchaudio.info
+        all_info = []
+        for path in candidates:
+            # <<< NEW: вместо info = torchaudio.info(path) ...
+            eq_len = self.path_info.get(path, 0)  # Получаем из кэша
+            all_info.append((eq_len, path))
+
+        # --- Ниже старый код, который был:
+        # for path in candidates:
+        #     try:
+        #         info = torchaudio.info(path)
+        #         length = info.num_frames
+        #         sr_ = info.sample_rate
+        #         eq_len = int(length / (sr_ / self.sample_rate)) if sr_ != self.sample_rate else length
+        #         all_info.append((eq_len, path))
+        #     except Exception as e:
+        #         logging.warning(f"⚠ Ошибка чтения {path}: {e}")
+
+        # 1) Фильтруем только >= min_needed
+        valid = [(l, p) for l, p in all_info if l >= min_needed]
+        logging.debug(f"✅ Подходящих (>= {min_needed}): {len(valid)} (из {len(all_info)})")
+
+        if valid:
+            # Если есть идеальные — берём случайно из них
+            random.shuffle(valid)
+            chosen = random.choice(valid)[1]
+            return chosen
+        else:
+            # 2) Если идеальных нет — берём топ-K по длине
+            sorted_by_len = sorted(all_info, key=lambda x: x[0], reverse=True)
+            top_k_list = sorted_by_len[:top_k]
+            if not top_k_list:
+                logging.debug("Нет доступных кандидатов вообще.")
+                return None  # вообще нет кандидатов
+
+            random.shuffle(top_k_list)
+            chosen = top_k_list[0][1]
+            logging.info(f"Из топ-{top_k} выбран кандидат: {chosen}")
+            return chosen
+
+    def run_whisper(self, waveform):
+        """
+        Вызывает Whisper на аудиосигнале и возвращает полный текст (без ограничения по количеству слов).
+        """
+        arr = waveform.squeeze().cpu().numpy()
+        try:
+            result = self.whisper_model.transcribe(arr, fp16=False)
+            text = result["text"].strip()
+            return text
+        except Exception as e:
+            logging.error(f"Whisper ошибка: {e}")
+            return ""
+
+    def emotion_to_vector(self, label_name):
+        """
+        Преобразует название эмоции в one-hot вектор (torch.tensor).
+        """
+        v = np.zeros(len(self.emotion_columns), dtype=np.float32)
+        if label_name in self.emotion_columns:
+            idx = self.emotion_columns.index(label_name)
+            v[idx] = 1.0
+        return torch.tensor(v, dtype=torch.float32)

data_loading/feature_extractor.py

@@ -0,0 +1,410 @@
+# data_loading/feature_extractor.py
+
+import torch
+import logging
+import numpy as np
+import torch.nn.functional as F
+from transformers import (
+    AutoFeatureExtractor,
+    AutoModel,
+    AutoTokenizer,
+    AutoModelForAudioClassification,
+    Wav2Vec2Processor
+)
+from data_loading.pretrained_extractors import EmotionModel, get_model_mamba, Mamba
+
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# DEVICE = torch.device('cpu')
+
+
+class PretrainedAudioEmbeddingExtractor:
+    """
+    Извлекает эмбеддинги из аудио, используя модель (например 'amiriparian/ExHuBERT'),
+    с учётом pooling, нормализации и т.д.
+    """
+
+    def __init__(self, config):
+        """
+        Ожидается, что в config есть поля:
+         - audio_model_name (str)         : название модели (ExHuBERT и т.п.)
+         - emb_device (str)              : "cpu" или "cuda"
+         - audio_pooling (str | None)    : "mean", "cls", "max", "min", "last" или None (пропустить пуллинг)
+         - emb_normalize (bool)          : делать ли L2-нормализацию выхода
+         - max_audio_frames (int)        : ограничение длины по временной оси (если 0 - не ограничивать)
+        """
+        self.config = config
+        self.device = config.emb_device
+        self.model_name = config.audio_model_name
+        self.pooling = config.audio_pooling       # может быть None
+        self.normalize_output = config.emb_normalize
+        self.max_audio_frames = getattr(config, "max_audio_frames", 0)
+        self.audio_classifier_checkpoint = config.audio_classifier_checkpoint
+
+        # Инициализируем processor и audio_embedder
+        self.processor = Wav2Vec2Processor.from_pretrained(self.model_name)
+        self.audio_embedder = EmotionModel.from_pretrained(self.model_name).to(self.device)
+
+        # Загружаем модель
+        self.classifier_model = self.load_classifier_model_from_checkpoint(self.audio_classifier_checkpoint)
+
+
+    def extract(self, waveform: torch.Tensor, sample_rate=16000):
+        """
+        Извлекает эмбеддинги из аудиоданных.
+
+        :param waveform: Тензор формы (T).
+        :param sample_rate: Частота дискретизации (int).
+        :return: Тензоры:
+            вернётся (B, classes), (B, sequence_length, hidden_dim).
+        """
+
+        embeddings = self.process_audio(waveform, sample_rate)
+        tensor_emb = torch.tensor(embeddings, dtype=torch.float32).to(self.device)
+        lengths = [tensor_emb.shape[1]]
+
+        with torch.no_grad():
+            logits, hidden = self.classifier_model(tensor_emb, lengths, with_features=True)
+
+            # Если pooling=None => вернём (B, seq_len, hidden_dim)
+            if hidden.dim() == 3:
+                if self.pooling is None:
+                    emb = hidden
+                else:
+                    if self.pooling == "mean":
+                        emb = hidden.mean(dim=1)
+                    elif self.pooling == "cls":
+                        emb = hidden[:, 0, :]
+                    elif self.pooling == "max":
+                        emb, _ = hidden.max(dim=1)
+                    elif self.pooling == "min":
+                        emb, _ = hidden.min(dim=1)
+                    elif self.pooling == "last":
+                        emb = hidden[:, -1, :]
+                    elif self.pooling == "sum":
+                        emb = hidden.sum(dim=1)
+                    else:
+                        emb = hidden.mean(dim=1)
+            else:
+                # На всякий случай, если получилось (B, hidden_dim)
+                emb = hidden
+
+        if self.normalize_output and emb.dim() == 2:
+            emb = F.normalize(emb, p=2, dim=1)
+
+        return logits, emb
+
+    def process_audio(self, signal: np.ndarray, sampling_rate: int) -> np.ndarray:
+        inputs = self.processor(signal, sampling_rate=sampling_rate, return_tensors="pt", padding=True)
+        input_values = inputs["input_values"].to(self.device)
+
+        with torch.no_grad():
+            outputs = self.audio_embedder(input_values)
+            embeddings = outputs
+
+        return embeddings.detach().cpu().numpy()
+
+    def load_classifier_model_from_checkpoint(self, checkpoint_path):
+        if checkpoint_path == "best_audio_model.pt":
+            checkpoint = torch.load(checkpoint_path, map_location=self.device)
+            exp_params = checkpoint['exp_params']
+            classifier_model = get_model_mamba(exp_params).to(self.device)
+            classifier_model.load_state_dict(checkpoint['model_state_dict'])
+        elif checkpoint_path == "best_audio_model_2.pt":
+            model_params = {
+                "input_size": 1024,
+                "d_model": 256,
+                "num_layers": 2,
+                "num_classes": 7,
+                "dropout": 0.2
+            }
+            classifier_model = get_model_mamba(model_params).to(self.device)
+            classifier_model.load_state_dict(torch.load(checkpoint_path, map_location=self.device))
+        classifier_model.eval()
+        return classifier_model
+
+class AudioEmbeddingExtractor:
+    """
+    Извлекает эмбеддинги из аудио, используя модель (например 'amiriparian/ExHuBERT'),
+    с учётом pooling, нормализации и т.д.
+    """
+
+    def __init__(self, config):
+        """
+        Ожидается, что в config есть поля:
+         - audio_model_name (str)         : название модели (ExHuBERT и т.п.)
+         - emb_device (str)              : "cpu" или "cuda"
+         - audio_pooling (str | None)    : "mean", "cls", "max", "min", "last" или None (пропустить пуллинг)
+         - emb_normalize (bool)          : делать ли L2-нормализацию выхода
+         - max_audio_frames (int)        : ограничение длины по временной оси (если 0 - не ограничивать)
+        """
+        self.config = config
+        self.device = config.emb_device
+        self.model_name = config.audio_model_name
+        self.pooling = config.audio_pooling       # может быть None
+        self.normalize_output = config.emb_normalize
+        # self.max_audio_frames = getattr(config, "max_audio_frames", 0)
+        self.max_audio_frames = config.sample_rate * config.wav_length
+
+
+        # Попробуем загрузить feature_extractor (не у всех моделей доступен)
+        try:
+            self.feature_extractor = AutoFeatureExtractor.from_pretrained(self.model_name)
+            logging.info(f"[Audio] Using AutoFeatureExtractor for '{self.model_name}'")
+        except Exception as e:
+            self.feature_extractor = None
+            logging.warning(f"[Audio] No built-in FeatureExtractor found. Model={self.model_name}. Error: {e}")
+
+        # Загружаем модель
+        # Если у модели нет head-классификации, бывает достаточно AutoModel
+        try:
+            self.model = AutoModel.from_pretrained(
+                self.model_name,
+                output_hidden_states=True   # чтобы точно был last_hidden_state
+            ).to(self.device)
+            logging.info(f"[Audio] Loaded AutoModel with output_hidden_states=True: {self.model_name}")
+        except Exception as e:
+            logging.warning(f"[Audio] Fallback to AudioClassification model. Reason: {e}")
+            self.model = AutoModelForAudioClassification.from_pretrained(
+                self.model_name,
+                output_hidden_states=True
+            ).to(self.device)
+
+    def extract(self, waveform_batch: torch.Tensor, sample_rate=16000):
+        """
+        Извлекает эмбеддинги из аудиоданных.
+
+        :param waveform_batch: Тензор формы (B, T) или (B, 1, T).
+        :param sample_rate: Частота дискретизации (int).
+        :return: Тензор:
+          - если pooling != None, будет (B, hidden_dim)
+          - если pooling == None и last_hidden_state имел форму (B, seq_len, hidden_dim),
+            вернётся (B, seq_len, hidden_dim).
+        """
+
+        # Если пришло (B, 1, T), уберём ось "1"
+        if waveform_batch.dim() == 3 and waveform_batch.shape[1] == 1:
+            waveform_batch = waveform_batch.squeeze(1)  # -> (B, T)
+
+        # Усечение по времени, если нужно
+        if self.max_audio_frames > 0 and waveform_batch.shape[1] > self.max_audio_frames:
+            waveform_batch = waveform_batch[:, :self.max_audio_frames]
+
+        # Если есть feature_extractor - используем
+        if self.feature_extractor is not None:
+            inputs = self.feature_extractor(
+                waveform_batch,
+                sampling_rate=sample_rate,
+                return_tensors="pt",
+                truncation=True,
+                max_length=self.max_audio_frames if self.max_audio_frames > 0 else None
+            )
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            outputs = self.model(input_values=inputs["input_values"])
+        else:
+            # Иначе подадим напрямую "input_values" на модель
+            inputs = {"input_values": waveform_batch.to(self.device)}
+            outputs = self.model(**inputs)
+
+        # Теперь outputs может быть BaseModelOutput (с last_hidden_state, hidden_states, etc.)
+        # Или SequenceClassifierOutput (с logits), если это модель-классификатор
+        if hasattr(outputs, "last_hidden_state"):
+            # (B, seq_len, hidden_dim)
+            hidden = outputs.last_hidden_state
+            # logging.debug(f"[Audio] last_hidden_state shape: {hidden.shape}")
+        elif hasattr(outputs, "logits"):
+            # logits: (B, num_labels)
+            # Для пуллинга по "seq_len" притворимся, что seq_len=1
+            hidden = outputs.logits.unsqueeze(1)  # (B,1,num_labels)
+            logging.debug(f"[Audio] Found logits shape: {outputs.logits.shape} => hidden={hidden.shape}")
+        else:
+            # Модель может сразу возвращать тензор
+            hidden = outputs
+
+        # Если у нас 2D-тензор (B, hidden_dim), значит всё уже спулено
+        if hidden.dim() == 2:
+            emb = hidden
+        elif hidden.dim() == 3:
+            # (B, seq_len, hidden_dim)
+            if self.pooling is None:
+                # Возвращаем как есть
+                emb = hidden
+            else:
+                # Выполним пуллинг
+                if self.pooling == "mean":
+                    emb = hidden.mean(dim=1)
+                elif self.pooling == "cls":
+                    emb = hidden[:, 0, :]  # [B, hidden_dim]
+                elif self.pooling == "max":
+                    emb, _ = hidden.max(dim=1)
+                elif self.pooling == "min":
+                    emb, _ = hidden.min(dim=1)
+                elif self.pooling == "last":
+                    emb = hidden[:, -1, :]
+                else:
+                    emb = hidden.mean(dim=1)  # на всякий случай fallback
+        else:
+            # На всякий: если ещё какая-то форма
+            raise ValueError(f"[Audio] Unexpected hidden shape={hidden.shape}, pooling={self.pooling}")
+
+        if self.normalize_output and emb.dim() == 2:
+            emb = F.normalize(emb, p=2, dim=1)
+
+        return emb
+
+
+class TextEmbeddingExtractor:
+    """
+    Извлекает эмбеддинги из текста (например 'jinaai/jina-embeddings-v3'),
+    с учётом pooling (None, mean, cls, и т.д.), нормализации и усечения.
+    """
+
+    def __init__(self, config):
+        """
+        Параметры в config:
+         - text_model_name (str)
+         - emb_device (str)
+         - text_pooling (str | None)
+         - emb_normalize (bool)
+         - max_tokens (int)
+        """
+        self.config = config
+        self.device = config.emb_device
+        self.model_name = config.text_model_name
+        self.pooling = config.text_pooling        # может быть None
+        self.normalize_output = config.emb_normalize
+        self.max_tokens = config.max_tokens
+
+        # trust_remote_code=True нужно для моделей вроде jina
+        logging.info(f"[Text] Loading tokenizer for {self.model_name} with trust_remote_code=True")
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.model_name,
+            trust_remote_code=True
+        )
+
+        logging.info(f"[Text] Loading model for {self.model_name} with trust_remote_code=True")
+        self.model = AutoModel.from_pretrained(
+            self.model_name,
+            trust_remote_code=True,
+            output_hidden_states=True,    # хотим иметь last_hidden_state
+            force_download=False
+        ).to(self.device)
+
+    def extract(self, text_list):
+        """
+        :param text_list: список строк (или одна строка)
+        :return: тензор (B, hidden_dim) или (B, seq_len, hidden_dim), если pooling=None
+        """
+
+        if isinstance(text_list, str):
+            text_list = [text_list]
+
+        inputs = self.tokenizer(
+            text_list,
+            padding="max_length",
+            truncation=True,
+            max_length=self.max_tokens,
+            return_tensors="pt"
+        )
+        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            # Обычно у AutoModel last_hidden_state.shape = (B, seq_len, hidden_dim)
+            hidden = outputs.last_hidden_state
+            # logging.debug(f"[Text] last_hidden_state shape: {hidden.shape}")
+
+            # Если pooling=None => вернём (B, seq_len, hidden_dim)
+            if hidden.dim() == 3:
+                if self.pooling is None:
+                    emb = hidden
+                else:
+                    if self.pooling == "mean":
+                        emb = hidden.mean(dim=1)
+                    elif self.pooling == "cls":
+                        emb = hidden[:, 0, :]
+                    elif self.pooling == "max":
+                        emb, _ = hidden.max(dim=1)
+                    elif self.pooling == "min":
+                        emb, _ = hidden.min(dim=1)
+                    elif self.pooling == "last":
+                        emb = hidden[:, -1, :]
+                    elif self.pooling == "sum":
+                        emb = hidden.sum(dim=1)
+                    else:
+                        emb = hidden.mean(dim=1)
+            else:
+                # На всякий случай, если получилось (B, hidden_dim)
+                emb = hidden
+
+        if self.normalize_output and emb.dim() == 2:
+            emb = F.normalize(emb, p=2, dim=1)
+
+        return emb
+
+class PretrainedTextEmbeddingExtractor:
+    """
+    Извлекает эмбеддинги из текста (например 'jinaai/jina-embeddings-v3'),
+    с учётом pooling (None, mean, cls, и т.д.), нормализации и усечения.
+    """
+
+    def __init__(self, config):
+        """
+        Параметры в config:
+         - text_model_name (str)
+         - emb_device (str)
+         - text_pooling (str | None)
+         - emb_normalize (bool)
+         - max_tokens (int)
+        """
+        self.config = config
+        self.device = config.emb_device
+        self.model_name = config.text_model_name
+        self.pooling = config.text_pooling        # может быть None
+        self.normalize_output = config.emb_normalize
+        self.max_tokens = config.max_tokens
+        self.text_classifier_checkpoint = config.text_classifier_checkpoint
+
+        self.model = Mamba(num_layers = 2, d_input = 1024, d_model = 512, num_classes=7, model_name=self.model_name, max_tokens=self.max_tokens, pooling=None).to(self.device)
+        checkpoint = torch.load(self.text_classifier_checkpoint, map_location=DEVICE)
+        self.model.load_state_dict(checkpoint['model_state_dict'])
+        self.model.eval()
+
+    def extract(self, text_list):
+        """
+        :param text_list: список строк (или одна строка)
+        :return: тензор (B, hidden_dim) или (B, seq_len, hidden_dim), если pooling=None
+        """
+
+        if isinstance(text_list, str):
+            text_list = [text_list]
+
+        with torch.no_grad():
+            logits, hidden = self.model(text_list, with_features=True)
+
+            if hidden.dim() == 3:
+                if self.pooling is None:
+                    emb = hidden
+                else:
+                    if self.pooling == "mean":
+                        emb = hidden.mean(dim=1)
+                    elif self.pooling == "cls":
+                        emb = hidden[:, 0, :]
+                    elif self.pooling == "max":
+                        emb, _ = hidden.max(dim=1)
+                    elif self.pooling == "min":
+                        emb, _ = hidden.min(dim=1)
+                    elif self.pooling == "last":
+                        emb = hidden[:, -1, :]
+                    elif self.pooling == "sum":
+                        emb = hidden.sum(dim=1)
+                    else:
+                        emb = hidden.mean(dim=1)
+            else:
+                # На всякий случай, если получилось (B, hidden_dim)
+                emb = hidden
+
+        if self.normalize_output and emb.dim() == 2:
+            emb = F.normalize(emb, p=2, dim=1)
+        return logits, emb

data_loading/pretrained_extractors.py

@@ -0,0 +1,221 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers import AutoTokenizer, AutoModel
+from transformers.models.wav2vec2.modeling_wav2vec2 import (
+    Wav2Vec2Model,
+    Wav2Vec2PreTrainedModel,
+)
+from torch.nn.functional import silu
+from torch.nn.functional import softplus
+from einops import rearrange, einsum
+from torch import Tensor
+from einops import rearrange
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# DEVICE = torch.device('cpu')
+
+## Audio models
+
+class CustomMambaBlock(nn.Module):
+    def __init__(self, d_input, d_model, dropout=0.1):
+        super().__init__()
+        self.in_proj = nn.Linear(d_input, d_model)
+        self.s_B = nn.Linear(d_model, d_model)
+        self.s_C = nn.Linear(d_model, d_model)
+        self.out_proj = nn.Linear(d_model, d_input)
+        self.norm = nn.LayerNorm(d_input)
+        self.dropout = nn.Dropout(dropout)
+        self.activation = nn.ReLU()
+
+    def forward(self, x):
+        x_in = x  # сохраняем вход
+        x = self.in_proj(x)
+        B = self.s_B(x)
+        C = self.s_C(x)
+        x = x + B + C
+        x = self.activation(x)
+        x = self.out_proj(x)
+        x = self.dropout(x)
+        x = self.norm(x + x_in)  # residual + norm
+        return x
+    
+class CustomMambaClassifier(nn.Module):
+    def __init__(self, input_size=1024, d_model=256, num_layers=2, num_classes=7, dropout=0.1):
+        super().__init__()
+        self.input_proj = nn.Linear(input_size, d_model)
+        self.blocks = nn.ModuleList([
+            CustomMambaBlock(d_model, d_model, dropout=dropout)
+            for _ in range(num_layers)
+        ])
+        self.fc = nn.Linear(d_model, num_classes)
+
+    def forward(self, x, lengths, with_features=False):
+        # x: (batch, seq_length, input_size)
+        x = self.input_proj(x)
+        for block in self.blocks:
+            x = block(x)
+        pooled = []
+        for i, l in enumerate(lengths):
+            if l > 0:
+                pooled.append(x[i, :l, :].mean(dim=0))
+            else:
+                pooled.append(torch.zeros(x.size(2), device=x.device))
+        pooled = torch.stack(pooled, dim=0)
+        if with_features:
+            return self.fc(pooled), x
+        else:
+            return self.fc(pooled)
+
+def get_model_mamba(params):
+    return CustomMambaClassifier(
+        input_size=params.get("input_size", 1024),
+        d_model=params.get("d_model", 256),
+        num_layers=params.get("num_layers", 2),
+        num_classes=params.get("num_classes", 7),
+        dropout=params.get("dropout", 0.1)
+    )
+
+class EmotionModel(Wav2Vec2PreTrainedModel):
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.wav2vec2 = Wav2Vec2Model(config)
+        self.init_weights()
+
+    def forward(self, input_values):
+        outputs = self.wav2vec2(input_values)
+        hidden_states = outputs[0]  # (batch_size, sequence_length, hidden_size)
+        return hidden_states
+    
+## Text models
+
+class Embedding():
+    def __init__(self, model_name='jinaai/jina-embeddings-v3', pooling=None):
+        self.model_name = model_name
+        self.pooling = pooling
+        self.device = DEVICE
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name, code_revision='da863dd04a4e5dce6814c6625adfba87b83838aa', trust_remote_code=True)
+        self.model = AutoModel.from_pretrained(model_name, code_revision='da863dd04a4e5dce6814c6625adfba87b83838aa', trust_remote_code=True).to(self.device)
+        self.model.eval()
+
+    def _mean_pooling(self, X):
+        def mean_pooling(model_output, attention_mask):
+            token_embeddings = model_output[0]
+            input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+            return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+        encoded_input = self.tokenizer(X, padding=True, truncation=True, return_tensors='pt').to(self.device)
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+        sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+        return sentence_embeddings.unsqueeze(1)
+    
+    def get_embeddings(self, X, max_len):
+        encoded_input = self.tokenizer(X, padding=True, truncation=True, return_tensors='pt').to(self.device)
+        with torch.no_grad():
+            features = self.model(**encoded_input)[0].detach().cpu().float().numpy()
+        res = np.pad(features[:, :max_len, :], ((0, 0), (0, max(0, max_len - features.shape[1])), (0, 0)), "constant")
+        return torch.tensor(res)
+        
+class RMSNorm(nn.Module):
+    def __init__(self, d_model: int, eps: float = 1e-8) -> None:
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x: Tensor) -> Tensor:        
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim = True) + self.eps) * self.weight
+
+class Mamba(nn.Module):
+    def __init__(self, num_layers, d_input, d_model, d_state=16, d_discr=None, ker_size=4, num_classes=7, max_tokens=95, model_name='jina', pooling=None):
+        super().__init__()
+        mamba_par = {
+            'd_input' : d_input,
+            'd_model' : d_model,
+            'd_state' : d_state,
+            'd_discr' : d_discr,
+            'ker_size': ker_size
+        }
+        self.model_name = model_name
+        self.max_tokens = max_tokens
+        embed = Embedding(model_name, pooling)
+        self.embedding = embed.get_embeddings
+        self.layers = nn.ModuleList([nn.ModuleList([MambaBlock(**mamba_par), RMSNorm(d_input)]) for _ in range(num_layers)])
+        self.fc_out = nn.Linear(d_input, num_classes)
+        self.device = DEVICE
+
+    def forward(self, seq, cache=None, with_features=True):
+        seq = self.embedding(seq, self.max_tokens).to(self.device)
+        for mamba, norm in self.layers:
+            out, cache = mamba(norm(seq), cache)
+            seq = out + seq
+        if with_features:
+            return self.fc_out(seq.mean(dim = 1)), seq
+        else:
+            return self.fc_out(seq.mean(dim = 1))
+        
+class MambaBlock(nn.Module):
+    def __init__(self, d_input, d_model, d_state=16, d_discr=None, ker_size=4):
+        super().__init__()
+        d_discr = d_discr if d_discr is not None else d_model // 16
+        self.in_proj  = nn.Linear(d_input, 2 * d_model, bias=False)
+        self.out_proj = nn.Linear(d_model, d_input, bias=False)
+        self.s_B = nn.Linear(d_model, d_state, bias=False)
+        self.s_C = nn.Linear(d_model, d_state, bias=False)
+        self.s_D = nn.Sequential(nn.Linear(d_model, d_discr, bias=False), nn.Linear(d_discr, d_model, bias=False),)
+        self.conv = nn.Conv1d(
+            in_channels=d_model,
+            out_channels=d_model,
+            kernel_size=ker_size,
+            padding=ker_size - 1,
+            groups=d_model,
+            bias=True,
+        )
+        self.A = nn.Parameter(torch.arange(1, d_state + 1, dtype=torch.float).repeat(d_model, 1))
+        self.D = nn.Parameter(torch.ones(d_model, dtype=torch.float))
+        self.device = DEVICE
+        
+    def forward(self, seq, cache=None):
+        b, l, d = seq.shape
+        (prev_hid, prev_inp) = cache if cache is not None else (None, None)
+        a, b = self.in_proj(seq).chunk(2, dim=-1)
+        x = rearrange(a, 'b l d -> b d l')
+        x = x if prev_inp is None else torch.cat((prev_inp, x), dim=-1)
+        a = self.conv(x)[..., :l]
+        a = rearrange(a, 'b d l -> b l d')
+        a = silu(a)
+        a, hid = self.ssm(a, prev_hid=prev_hid) 
+        b = silu(b)
+        out = a * b
+        out =  self.out_proj(out)
+        if cache:
+            cache = (hid.squeeze(), x[..., 1:])   
+        return out, cache
+    
+    def ssm(self, seq, prev_hid):
+        A = -self.A
+        D = +self.D
+        B = self.s_B(seq)
+        C = self.s_C(seq)
+        s = softplus(D + self.s_D(seq))
+        A_bar = einsum(torch.exp(A), s, 'd s,   b l d -> b l d s')
+        B_bar = einsum(          B,  s, 'b l s, b l d -> b l d s')
+        X_bar = einsum(B_bar, seq, 'b l d s, b l d -> b l d s')
+        hid = self._hid_states(A_bar, X_bar, prev_hid=prev_hid)
+        out = einsum(hid, C, 'b l d s, b l s -> b l d')
+        out = out + D * seq
+        return out, hid
+    
+    def _hid_states(self, A, X, prev_hid=None):
+        b, l, d, s = A.shape
+        A = rearrange(A, 'b l d s -> l b d s')
+        X = rearrange(X, 'b l d s -> l b d s')
+        if prev_hid is not None:
+            return rearrange(A * prev_hid + X, 'l b d s -> b l d s')
+        h = torch.zeros(b, d, s, device=self.device)
+        return torch.stack([h := A_t * h + X_t for A_t, X_t in zip(A, X)], dim=1)
+

emotion_templates/anger.json

@@ -0,0 +1,196 @@
+{
+  "subjects": [
+    "That lie", "This situation", "His attitude", "Her silence", "The way they ignored me",
+    "That decision", "This whole mess", "His response", "The way they talked to me",
+    "Their tone", "The look in their eyes", "The unfairness", "The betrayal",
+    "This conversation", "The rules they made", "That smug smile", "The injustice",
+    "His arrogance", "Her hypocrisy", "That fake apology", "Their excuse",
+    "What happened", "That accusation", "Their assumption", "His coldness",
+    "The way they dismissed me", "The way she walked away", "Their comment",
+    "The lack of respect", "The silence", "The manipulation", "The fake concern",
+    "This nonsense", "Their reaction", "The way they handled it", "The favoritism",
+    "That email", "The way they gaslit me", "This double standard", "The broken promise",
+    "Her message", "His ignorance", "The constant interruptions", "The yelling",
+    "The lies they spread", "Their decision", "This treatment", "His sarcasm",
+    "The rolled eyes", "This chaos", "The way they brushed it off", "The crossed line",
+    "Their behavior", "The gaslighting", "That moment", "Her denial", "The lack of accountability",
+    "His manipulation", "Their fake smile", "The passive aggression", "The backhanded comment",
+    "Her voice", "His condescension", "The disrespect", "The way I was ignored",
+    "The raised voice", "The rules for them", "The expectations they set", "That stupid joke",
+    "The fake empathy", "The unfair treatment", "That meeting", "That statement",
+    "The constant blame", "The way they twisted my words", "The tone they used",
+    "That decision they made", "The control", "Their agenda", "The things they said",
+    "That smug look", "The whispering", "Their manipulation", "The criticism",
+    "Her smugness", "His blank stare", "The gaslight attempt", "The guilt trip",
+    "The two-faced attitude", "The pressure", "The invalidation", "The dismissal",
+    "This tension", "The accusations", "The disrespectful comment", "The dishonesty",
+    "The fake kindness", "This nonsense policy", "Their entitlement", "The red flags",
+    "The toxic vibe", "The constant judgment", "The unnecessary drama", "His defensiveness"
+  ],
+  "verbs": [
+    "set me off", "boiled my blood", "pushed me over the edge", "got under my skin",
+    "made me snap", "triggered me instantly", "infuriated me", "was unbearable",
+    "sparked pure rage", "ticked me off", "made my fists clench", "was too much",
+    "ignited everything", "set a fire in me", "boiled over", "made my blood rush",
+    "shook me with anger", "cut too deep", "threw me into rage", "was beyond frustrating",
+    "hit a nerve", "was infuriating", "drove me mad", "burned inside me", "got to me",
+    "turned me red", "filled me with heat", "was outrageous", "was completely unacceptable",
+    "ripped through me", "kept poking at me", "got louder and louder", "spun me out",
+    "made me want to scream", "felt like an attack", "built up fast", "couldn’t be ignored",
+    "turned everything red", "sent me into a spiral", "clashed with everything in me",
+    "pressed all my buttons", "erased my patience", "had me yelling inside", "spilled over fast",
+    "was a slap in the face", "put me in fight mode", "snapped something in me", "took it too far",
+    "crossed a line", "felt like fuel", "burned through me", "got personal", "hit my limits",
+    "killed my calm", "shot adrenaline through me", "woke the worst in me", "soured the whole day",
+    "made me want to throw something", "burned me out", "was like fire in my gut", "dismantled my tolerance",
+    "overwhelmed me", "shattered my cool", "tore through my brain", "clanged in my chest",
+    "stabbed at my peace", "chased my breath", "spit in my face", "made me want to walk out",
+    "boomed inside", "grew louder", "flared without warning", "grated every nerve",
+    "felt like betrayal", "hammered on my mind", "flipped my mood instantly", "exploded internally",
+    "twisted my stomach", "simmered too long", "kept repeating in my head", "built up in silence",
+    "felt relentless", "crept up slowly", "left me livid", "killed all reason", "tore open my restraint",
+    "blocked out everything else", "just wouldn't stop", "sparked a storm", "dragged me into rage",
+    "stabbed at my patience", "flooded me with fury", "split my brain", "left me shaking",
+    "was like fire to paper", "ripped up my peace", "wrecked my day", "tipped me over",
+    "woke something primal", "restarted the fire", "slammed into my chest", "blew my fuse"
+  ],
+  "interjections": [
+    "You’ve got to be kidding me (groans)!",
+    "(inhales) This is unreal!",
+    "Seriously (clears throat)?",
+    "I can’t even begin (inhales)...",
+    "Enough is enough (groans)!",
+    "What the hell (exhales)!",
+    "Are you serious (groans)?",
+    "This has to stop (inhales)!",
+    "I’ve had it (groans)!",
+    "I’m not holding back (clears throat).",
+    "Now I’m done (inhales).",
+    "Unbelievable (groans).",
+    "Not again (exhales)...",
+    "That’s it (groans)!",
+    "I swear (clears throat).",
+    "How dare they (inhales)!",
+    "Absolutely not (groans)!",
+    "Get out of here (screams)!",
+    "I’m done pretending (inhales).",
+    "No way (groans)."
+  ],
+
+  "contexts": [
+    "and I couldn’t stay quiet (groans)",
+    "and I snapped (exhales) without warning",
+    "and I couldn’t control my voice (inhales)",
+    "and I felt the heat rise (exhales)",
+    "and I wanted to punch a wall (inhales)",
+    "and I yelled (screams) before I could stop",
+    "and it shattered my calm (groans)",
+    "and I lost it right there (groans)",
+    "and I (inhales) slammed the door",
+    "and I could feel myself shaking (groans)",
+    "and my jaw locked tight (exhales)",
+    "and I couldn’t hold it in (groans)",
+    "and I was done pretending (clears throat)",
+    "and I couldn’t even look at them (inhales)",
+    "and I exploded (groans)",
+    "and I couldn’t take it anymore (exhales)",
+    "and I had to say something (groans)",
+    "and I (inhales) stood my ground",
+    "and I shouted back (screams)",
+    "and I let it all out (exhales)",
+    "and my voice (clears throat) cracked",
+    "and I hit the table (groans)",
+    "and my chest was pounding (inhales)",
+    "and I was ready to walk out (groans)",
+    "and I didn’t care anymore (exhales)",
+    "and I needed to be heard (clears throat)",
+    "and I (inhales) raised my voice",
+    "and I threw the paper (groans)",
+    "and I stormed out (screams)",
+    "and I couldn’t stay still (inhales)",
+    "and I lost all patience (groans)",
+    "and I refused to let it slide (groans)",
+    "and I called them out (clears throat)",
+    "and I (inhales) slammed my hand down",
+    "and I saw red (groans)",
+    "and I swore (exhales) under my breath",
+    "and I (inhales) pushed back",
+    "and I made it clear (clears throat)",
+    "and I couldn’t smile through it (exhales)",
+    "and I wasn’t going to take it (groans)",
+    "and I felt fury (inhales) in my chest",
+    "and I almost screamed (groans)",
+    "and I nearly broke something (exhales)",
+    "and I didn’t care who heard (groans)",
+    "and I just (inhales) let it rip",
+    "and I couldn’t stop (groans)",
+    "and I raised hell (screams)",
+    "and I felt every nerve snap (inhales)",
+    "and I threw my phone (groans)",
+    "and I stood up fast (exhales)",
+    "and I couldn’t think straight (groans)",
+    "and I almost walked out (inhales)",
+    "and I hit the wall (groans)",
+    "and I didn’t hold back (clears throat)",
+    "and I wasn’t sorry (groans)",
+    "and I didn’t fake calm (inhales)",
+    "and I pushed through the rage (groans)",
+    "and I didn’t even blink (exhales)",
+    "and I said (inhales) exactly what I felt",
+    "and I glared back (groans)",
+    "and I lost all control (exhales)",
+    "and I roared inside (groans)",
+    "and I hit my breaking point (inhales)",
+    "and I wasn’t about to be silent (groans)",
+    "and I couldn’t take another second (exhales)",
+    "and I let the fury speak (groans)",
+    "and I (inhales) dropped the act",
+    "and I watched myself boil (groans)",
+    "and I nearly lost it all (exhales)",
+    "and I refused to back down (groans)",
+    "and I didn’t sugarcoat it (clears throat)",
+    "and I let the anger talk (groans)",
+    "and I (inhales) cut them off",
+    "and I burned the bridge (groans)",
+    "and I pulled no punches (inhales)",
+    "and I growled back (groans)",
+    "and I lashed out (exhales)",
+    "and I let it burn (groans)",
+    "and I needed the release (inhales)",
+    "and I was done holding it in (groans)",
+    "and I let the room know (inhales)",
+    "and I banged the table (groans)",
+    "and I spit the words out (inhales)",
+    "and I slammed my fist (groans)",
+    "and I (inhales) snapped hard",
+    "and I said it louder (groans)",
+    "and I faced it head‑on (exhales)",
+    "and I let the silence burn (groans)",
+    "and I felt the power rise (inhales)",
+    "and I walked away fuming (groans)",
+    "and I cracked wide open (exhales)",
+    "and I gave them the truth (groans)",
+    "and I looked them dead in the eyes (inhales)",
+    "and I didn’t regret it (exhales)"
+  ],
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i} {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} just... {v}. {c}.",
+    "{i} — {s} {v}, {c}.",
+    "What set me off? {s} {v}. {c}.",
+    "{s} {v}. I had enough! {c}.",
+    "{s} {v}, and I didn’t hold back. {c}.",
+    "I lost it when {s} {v}, {c}.",
+    "You want to know why I snapped? {s} {v}.",
+    "And then it happened: {s} {v}, {c}.",
+    "{s} {v}. I couldn’t take one more second! {c}.",
+    "{s} {v}. That was the last straw!",
+    "{i} I saw red when {s} {v}. {c}.",
+    "{s} {v}. I slammed the damn door. {c}."
+  ]
+}

emotion_templates/disgust.json

@@ -0,0 +1,174 @@
+{
+  "subjects": [
+    "That smell", "This mess", "The way they chew", "The bathroom", "That habit",
+    "The leftover food", "The sink", "The way he talks", "The mold", "Her fake laugh",
+    "The dirty plate", "His comment", "The old sponge", "The floor", "That photo",
+    "The rotten food", "The spoiled milk", "The sweat smell", "That video",
+    "The way she looked at me", "The chewing sound", "That creepy grin", "The fridge",
+    "The slime", "The trash", "His breath", "The sound of slurping", "The bug",
+    "The pus", "The stain", "The toilet", "The crusted towel", "The unwashed dish",
+    "The clump of hair", "The spit", "That burp", "The toenail clipping",
+    "The used tissue", "The crust in the corner", "The food stuck to the table",
+    "The pile of clothes", "The smudge", "That smell in the microwave", "The grime",
+    "The grease", "The way they eat with their mouth open", "The way he scratched",
+    "The loud chewing", "The mucus", "That nasty cough", "The dirty keyboard",
+    "The open sore", "The bathroom floor", "That weird stain", "The gum under the desk",
+    "The way she licked her fingers", "That slimy texture", "The hair in the drain",
+    "The oil smell", "The weird texture", "That flaky skin", "The cough in my face",
+    "The dried ketchup", "The fake smile", "The old food container", "The spit bubble",
+    "The breath in my face", "The noisy swallowing", "The crusty fork", "The plate of mush",
+    "The gurgling sound", "The smelly shoe", "The grease trap", "The used napkin",
+    "The close talker", "The public bathroom", "The noise he made", "The dirty towel",
+    "The slime on the floor", "The gunk", "The mix of smells", "The empty bottle with milk in it",
+    "That gesture", "The broken nail", "The eye gunk", "That noise with the throat",
+    "The mess in the sink", "The weird breathing", "The sticky hand", "The stinky feet",
+    "The trash bag leak", "The way they touched the food", "The finger licking",
+    "The bathroom stall", "That cracked lip", "The greasy spoon", "The way they smacked their lips"
+  ],
+  "verbs": [
+    "turned my stomach", "made me gag", "grossed me out", "made me shiver",
+    "sent a wave of nausea", "was disgusting", "made me flinch", "twisted my gut",
+    "churned my stomach", "repulsed me", "triggered my gag reflex",
+    "made my skin crawl", "was revolting", "sickened me", "hit me wrong",
+    "burned my nose", "felt wrong", "made me dry heave", "pushed me back",
+    "curdled my insides", "stung my senses", "brought bile up", "left a taste in my mouth",
+    "smelled rancid", "tasted foul", "looked putrid", "reeked", "felt like vomit",
+    "left me nauseated", "knocked my appetite", "made me lose it",
+    "felt filthy", "stank horribly", "coated my throat", "overwhelmed my nose",
+    "burned into memory", "made me cough", "was rotten", "was unbearable",
+    "left me disgusted", "sent shivers", "twisted my face", "gave me goosebumps",
+    "triggered disgust", "was sickening", "was grotesque", "reeked of old filth",
+    "smelled like death", "was unspeakable", "looked infected", "was slimy and warm",
+    "was moist in the worst way", "left a greasy film", "was sticky and gross",
+    "stuck to everything", "oozed", "dripped in the worst way", "was decaying",
+    "looked chewed", "felt rancid", "smelled spoiled", "squished in my hand",
+    "glistened weirdly", "looked alive", "wiggled slightly", "felt damp and wrong",
+    "left a slime trail", "made me cover my mouth", "caused a dry retch",
+    "spoiled the whole room", "felt like rot", "reeked of sweat", "oozed a bit",
+    "smeared across the surface", "clung to the air", "infected the vibe",
+    "spread filth", "made everything worse", "crawled under my skin",
+    "was so wrong", "ruined my day", "tasted like trash", "bubbled weirdly",
+    "had texture like decay", "looked chewed up", "smelled like feet",
+    "smelled fermented", "smeared all over", "cracked and oozed", "sent a gag reflex",
+    "looked diseased", "felt like warm spit", "reeked of mold", "coated my senses"
+  ],
+"interjections": [
+    "(groans) Ew!",
+    "(coughs) That’s disgusting!",
+    "Ugh! (sniffs)",
+    "(gasps) I can’t believe I saw that",
+    "Seriously? (sighs)",
+    "(groans) What the hell?!",
+    "No no no! (clears throat)",
+    "Gross! (exhales)",
+    "(mumbles) Disgusting!",
+    "That made me gag! (coughs)",
+    "(sniffs) Yuck!",
+    "Oh god (groans)",
+    "That’s so wrong! (exhales)",
+    "Why would you do that?! (clears throat)",
+    "(inhales) Please stop",
+    "That smell though (sniffs)",
+    "No thanks (sighs)",
+    "I’m done (groans)",
+    "Absolutely vile! (coughs)",
+    "I could puke! (exhales)"
+  ],
+
+  "contexts": [
+    "(groans) and I couldn’t unsee it",
+    "and I nearly gagged (coughs)",
+    "and I felt my throat close (exhales)",
+    "and I turned away (groans)",
+    "and I had to leave the room (exhales)",
+    "and my face twisted (sniffs)",
+    "and I backed off immediately (groans)",
+    "and I clenched my jaw (sighs)",
+    "and I wanted to scrub my brain (groans)",
+    "and my appetite vanished (clears throat)",
+    "and I wiped my hands (sniffs)",
+    "and I needed mouthwash (groans)",
+    "and I felt queasy (coughs)",
+    "(sniffs) and I covered my nose",
+    "and I said ‘gross!’ (groans)",
+    "and I still smell it (sniffs)",
+    "and I wanted to burn it all (exhales)",
+    "and I nearly lost it (groans)",
+    "and I shook my head (sighs)",
+    "and I whispered ‘what the hell?!’ (groans)",
+    "and I flinched hard (inhales)",
+    "and I squinted like it would go away (sighs)",
+    "(inhales) and I held my breath",
+    "and I gagged a little (coughs)",
+    "and I pulled back fast (groans)",
+    "and I rubbed my eyes (sniffs)",
+    "and I dry heaved (coughs)",
+    "and I bit my tongue to avoid screaming (clears throat)",
+    "and I washed my hands three times (sniffs)",
+    "and I didn’t look again (groans)",
+    "and I covered my face (exhales)",
+    "and I had to breathe through my mouth (inhales)",
+    "and I said ‘absolutely not!’ (groans)",
+    "and I scrubbed everything (sniffs)",
+    "and I needed a shower (groans)",
+    "and I said ‘ew!’ out loud (coughs)",
+    "and I sprayed the whole area (coughs)",
+    "and I glared at them (clears throat)",
+    "and I wiped the table like five times (sniffs)",
+    "and I wanted to bleach it (groans)",
+    "and I swore never again (exhales)",
+    "and I asked them to stop (clears throat)",
+    "and I backed into a corner (inhales)",
+    "and I wanted to scream (groans)",
+    "and I asked them to throw it away (clears throat)",
+    "and I almost dropped it (gasps)",
+    "and I cringed (groans)",
+    "and I winced hard (inhales)",
+    "and I had to spit (coughs)",
+    "and I cleaned everything I touched (sniffs)",
+    "and I looked away fast (groans)",
+    "and I felt like vomiting (coughs)",
+    "and I dry swallowed (sighs)",
+    "and I left the room immediately (exhales)",
+    "and I didn’t know what to do (sighs)",
+    "and I needed to rinse my mouth (clears throat)",
+    "and I still feel it on my hands (sniffs)",
+    "and I wiped my phone off (sniffs)",
+    "and I stood there stunned (gasps)",
+    "and I whispered ‘nope!’ (groans)",
+    "and I tensed up (inhales)",
+    "and I wiped down the table again (sniffs)",
+    "(coughs) and I sprayed disinfectant everywhere",
+    "and I held the air (inhales)",
+    "and I tried not to vomit (coughs)",
+    "and I shook it off quickly (exhales)",
+    "and I walked away fast (groans)",
+    "and I stared in horror (gasps)",
+    "and I flinched again (inhales)",
+    "and I cleaned the whole area (sniffs)",
+    "and I sanitized everything (clears throat)",
+    "and I stepped away (exhales)"
+  ],
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}, {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} just... {v}. {c}.",
+    "{i} — {s} {v}, {c}.",
+    "Honestly, {s} {v}. {c}.",
+    "I couldn’t take it — {s} {v}, {c}.",
+    "It was foul. {s} {v}. {c}.",
+    "Just thinking about it — {s} {v}. {c}.",
+    "‘{s} {v}’ — yeah, I’m out. {c}.",
+    "{s} made me gag, no question. {c}.",
+    "I still feel sick. {s} {v}. {c}.",
+    "It turned my gut — {s} {v}, {c}.",
+    "{s}? Just vile. {v}, {c}.",
+    "Disgust doesn’t even cover it — {s} {v}, {c}.",
+    "{i}. Seriously, {s} {v}. {c}.",
+    "Every time I remember — {s} {v}. {c}."
+  ]
+}

emotion_templates/fear.json

@@ -0,0 +1,178 @@
+{
+  "subjects": [
+    "That noise", "The silence", "This feeling", "His stare", "Her whisper", "That look",
+    "The shadow", "The knock", "That voice", "The unknown", "The hallway", "The message",
+    "The basement", "The flicker", "That sound behind me", "The reflection", "The darkness",
+    "The quiet", "That face", "The empty street", "The open door", "The figure in the distance",
+    "The footsteps", "The breath I heard", "The locked room", "The sudden cold", "The static",
+    "The glitch", "That motion", "The silence after", "That sudden stop", "The blank screen",
+    "The basement light", "The empty chair", "The way it stopped", "The timing", "The phone ringing",
+    "The strange call", "The echo", "The scream", "The eye contact", "The ticking", "The delay",
+    "That message at night", "The wrong number", "The unexpected knock", "The closed curtain",
+    "The way it moved", "The window", "The mirror", "The shape", "The silence on the line",
+    "The dim hallway", "That heavy breath", "The door creaking", "The chill", "That shadow on the wall",
+    "The open browser tab", "The stillness", "The unanswered call", "The flickering light",
+    "The power going out", "That smell", "The voice in my head", "The basement stairs",
+    "The unknown number", "The sudden pause", "The air around me", "The shape behind me",
+    "The clicking sound", "The lack of sound", "That dream", "The phone buzz", "The siren",
+    "That change in tone", "The knock I didn’t expect", "The door left open", "That breath I didn’t take",
+    "The space under the bed", "The open closet", "The camera turning on", "The power surge",
+    "That sudden silence", "The hallway light", "The alarm", "The code not working",
+    "That sudden breeze", "The voice that stopped", "The quiet tap", "The screen glitch",
+    "That blinking cursor", "The slow footsteps", "The eye in the dark", "The frozen time",
+    "The disconnect tone", "The feeling of being watched", "The stop in motion", "The email I didn’t send"
+  ],
+  "verbs": [
+    "froze me", "sent a chill down my spine", "made my breath catch", "stopped my heart",
+    "tied my stomach in knots", "paralyzed me", "had me holding my breath", "rushed my pulse",
+    "tensed every muscle", "squeezed my chest", "made me dizzy", "triggered my panic",
+    "gripped me", "shook me", "dried my mouth", "shrank my world", "knocked me still",
+    "pressed on my lungs", "made my skin crawl", "trembled through me", "dug into my mind",
+    "raced through my thoughts", "tightened my throat", "blanked my head", "flooded me with fear",
+    "spiked my heart rate", "stole my breath", "made me freeze in place", "clouded my focus",
+    "hit like dread", "echoed in my chest", "spun my senses", "stung like ice", "gripped my spine",
+    "whitened my face", "stopped everything", "grew louder in my head", "seeped into me",
+    "dragged down my breath", "set my nerves on edge", "crawled over my skin", "burned in my gut",
+    "snapped my focus", "locked my body", "flooded my system", "choked my breath",
+    "tightened my jaw", "made my heartbeat deafening", "pressed me into stillness",
+    "caged my breath", "made my ears ring", "left me lightheaded", "slowed down time",
+    "reduced me to silence", "took over", "made my hands shake", "bent my knees",
+    "tugged at my ribs", "dimmed my sight", "pulled me inward", "buried my voice",
+    "unraveled me", "set alarms off inside", "curled my fingers", "hit my core",
+    "trembled in my jaw", "scrambled my thoughts", "turned me to stone", "squeezed my spine",
+    "widened my eyes", "flushed my skin", "knocked the air out", "rattled my head",
+    "sat heavy in my chest", "clutched at my throat", "sent panic through me",
+    "knotted my back", "held me hostage", "blinded my thinking", "muffled my hearing",
+    "rose like a wave", "climbed through my limbs", "forced my jaw shut", "twisted in my gut",
+    "burned through my nerves", "flooded my eyes", "froze my voice", "slammed my chest",
+    "disoriented me", "hollowed me out", "rushed like a scream", "scraped my bones",
+    "throbbed in my neck", "tightened like a noose", "spun in my head", "felt like doom"
+  ],
+  "contexts": [
+    "(gasps) and I couldn’t move",
+    "and I held my breath (inhales)",
+    "and my body locked up (exhales)",
+    "and I didn’t know what to do (sighs)",
+    "and I felt eyes on me (inhales)",
+    "and I just listened (sighs)",
+    "and I froze in place (gasps)",
+    "and everything felt too quiet (exhales)",
+    "and I scanned the room (inhales)",
+    "and I backed away (gasps)",
+    "and I reached for my phone (inhales)",
+    "and I whispered nothing (sighs)",
+    "and I stayed absolutely still (exhales)",
+    "and I clenched my jaw",
+    "and I waited in silence (exhales)",
+    "and I couldn’t see clearly (exhales)",
+    "and my heart was pounding (inhales)",
+    "and the air felt wrong (sighs)",
+    "and I tiptoed (inhales)",
+    "and my hands were shaking (exhales)",
+    "and I hoped it wasn’t real (sighs)",
+    "and I didn’t dare speak (inhales)",
+    "and I tried to stay calm (exhales)",
+    "and the walls felt closer (gasps)",
+    "and the room spun (exhales)",
+    "and I avoided the mirror (sighs)",
+    "and I wished I hadn’t heard that (exhales)",
+    "and the lights flickered (gasps)",
+    "and the sound repeated (inhales)",
+    "and my fingers curled (exhales)",
+    "and I stood frozen (gasps)",
+    "and I looked over my shoulder (inhales)",
+    "and I barely breathed (exhales)",
+    "and I felt like I was watched (gasps)",
+    "and I clutched my chest (inhales)",
+    "and my breath stopped (exhales)",
+    "and I whispered ‘hello?’ (sighs)",
+    "and I stepped back slowly (exhales)",
+    "and I avoided eye contact (sighs)",
+    "and I didn’t turn around (inhales)",
+    "and I closed my eyes tight (exhales)",
+    "and I mouthed ‘please no’ (sighs)",
+    "and I turned the light on (inhales)",
+    "and I checked the door (exhales)",
+    "and I hoped it was nothing (sighs)",
+    "and I bit my lip (inhales)",
+    "and I looked again (gasps)",
+    "and I grabbed the handle (inhales)",
+    "and I watched the hallway (exhales)",
+    "and I held the wall (sighs)",
+    "and I tried not to blink (inhales)",
+    "and I prayed I was wrong (exhales)",
+    "and I counted my breaths (sighs)",
+    "and I waited for a sound (inhales)",
+    "and I pressed my back to the wall (exhales)",
+    "and I closed the tab (sighs)",
+    "and I locked my phone (inhales)",
+    "and I shook (exhales)",
+    "and I tried to steady myself (sighs)",
+    "and I looked away (exhales)",
+    "and I froze mid‑step (gasps)",
+    "and I turned down the volume (sighs)",
+    "and I stood in the dark (inhales)",
+    "and I checked the lock (exhales)",
+    "and I peeked through the curtain (gasps)",
+    "and I watched the shadow move (inhales)",
+    "and I saw it again (exhales)",
+    "and I hoped I imagined it (sighs)",
+    "and I wanted to scream (gasps)",
+    "and I felt something shift (inhales)",
+    "and I barely exhaled (exhales)",
+    "and I pressed mute (sighs)",
+    "and I whispered ‘stop’ (inhales)",
+    "and I stared into the dark (exhales)",
+    "and I held my breath again (inhales)",
+    "and I tried to wake up (sighs)",
+    "and I reached for the light (inhales)",
+    "and I stayed under the blanket (exhales)",
+    "and I whispered to myself (sighs)",
+    "and I looked at the screen again (inhales)",
+    "and I locked the window (exhales)",
+    "and I flinched (gasps)",
+    "and I felt it behind me (inhales)",
+    "and I turned off the TV (exhales)",
+    "and I pulled the covers tight (sighs)"
+  ],
+
+  "interjections": [
+    "(gasps) I felt a chill!",
+    "(sighs) Something’s off.",
+    "(exhales) This can’t be good.",
+    "I don’t like this (inhales).",
+    "(inhales) What if it’s real?",
+    "(gasps) No way!",
+    "I swear I saw something (exhales).",
+    "(inhales) Did you hear that?",
+    "(sighs) Why is it so quiet?",
+    "That wasn’t right (exhales).",
+    "(inhales) Is someone there?",
+    "Not again (exhales)...",
+    "(exhales) That gave me chills.",
+    "(gasps) What the...",
+    "It felt wrong (sighs).",
+    "(gasps) I froze!",
+    "(gasps) Something moved!",
+    "(sighs) It’s too quiet.",
+    "(exhales) This isn’t normal.",
+    "(inhales) I’m not alone."
+  ],
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}, {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} just... {v}. {c}.",
+    "{i} — {s} {v}, {c}.",
+    "{s} {v}. I couldn’t blink. {c}.",
+    "And then it happened: {s} {v}, {c}.",
+    "‘{s} {v}’ — and I froze. {c}.",
+    "It was quiet, too quiet. Then {s} {v}. {c}.",
+    "I stopped breathing when {s} {v}. {c}.",
+    "No one else noticed, but {s} {v}, {c}.",
+    "{s} {v}. My pulse spiked. {c}."
+  ]
+}

emotion_templates/happy.json

@@ -0,0 +1,187 @@
+{
+  "subjects": [
+    "That moment", "This message", "Her smile", "His laugh", "The sunshine", "The good news",
+    "That call", "The unexpected text", "The gift", "The surprise", "That compliment",
+    "The way they looked at me", "This day", "The win", "That hug", "The way it happened",
+    "Their reaction", "That unexpected turn", "This feeling", "That morning",
+    "The celebration", "The results", "That gesture", "The quiet joy", "The party",
+    "The sound of laughter", "The light", "That one word", "The surprise visit",
+    "The smell of coffee", "The fresh air", "The freedom", "That one dance",
+    "The sunrise", "The music", "The rhythm", "The warm breeze", "That smile across the room",
+    "The perfect timing", "The peace", "The joke", "The message I didn’t expect",
+    "That moment I opened the door", "The reaction on their face", "That memory",
+    "The sparkle in their eyes", "The unexpected break", "The lucky moment",
+    "The right words", "The song that played", "The cake", "The light in the room",
+    "The kids laughing", "The compliments", "The photo", "The way they cheered",
+    "The shared silence", "That warm feeling", "The burst of joy", "The freedom I felt",
+    "The high five", "The small win", "The huge success", "The laughter we shared",
+    "The trip", "The story", "The goofy face", "The text with all caps",
+    "The silly moment", "The happy tear", "The peace in my heart", "The sparkle",
+    "The good vibes", "The cozy night", "The unexpected yes", "The sudden dance",
+    "The applause", "The open road", "The sunshine on my face", "The joke that landed",
+    "The moment they said it", "The sparkle of hope", "The confetti moment", "That yes",
+    "The bounce in their step", "The rush of relief", "The random kindness",
+    "The shared look", "The clink of glasses", "The moment of pride", "The nod of approval",
+    "The lightness in the air", "The smell of cookies", "The favorite song",
+    "The surprise package", "The right time", "That perfect moment", "The cheers",
+    "The warmth in the room", "The silly dance", "The peace in the pause", "The bright light"
+  ],
+  "verbs": [
+    "lit me up", "made me laugh out loud", "warmed my chest", "brought me peace",
+    "lifted my mood", "was pure joy", "felt like flying", "was exactly what I needed",
+    "made me grin", "sparked something bright", "filled me with light",
+    "was everything", "cheered me up", "set the tone", "made the whole day",
+    "was perfect", "was a blessing", "felt magical", "recharged me", "was unforgettable",
+    "made my heart dance", "put a smile on my face", "made my eyes shine",
+    "woke up my soul", "filled the room", "shimmered through me", "set me free",
+    "bubbled up inside", "sparked so much joy", "brought out my laughter",
+    "was heartwarming", "had me laughing instantly", "soothed my spirit",
+    "gave me goosebumps", "sparkled", "changed everything", "was so genuine",
+    "had me beaming", "was sunshine", "shined bright", "was golden",
+    "made the room feel lighter", "brought instant joy", "was beautiful",
+    "echoed with joy", "brightened the moment", "lifted the weight",
+    "refreshed my spirit", "wrapped me in warmth", "was the highlight",
+    "gave me hope", "touched my heart", "made me giggle", "felt light and free",
+    "restored my smile", "made me blush", "sparkled in me", "woke something kind",
+    "was soft and strong", "wrapped the moment", "was like magic", "felt like home",
+    "was full of grace", "was the best surprise", "was the perfect fit", "bloomed inside me",
+    "brought clarity and calm", "was so full of color", "set off a spark",
+    "played like a melody", "made everything brighter", "was like spring inside me",
+    "was sweetness", "glowed in me", "reminded me of good things", "restored my joy",
+    "hugged me from within", "was full of wonder", "sparkled in my chest", "was so soft",
+    "helped me breathe again", "was a true gift", "felt so human", "rang like laughter",
+    "set me dancing", "was pure love", "made me giggle-snort", "sent joy down my spine",
+    "was completely silly", "was just right", "was light as air", "was like a hug",
+    "fizzed like soda", "made my heart sing", "was total delight", "filled the space with light",
+    "was cozy and bright", "carried me", "felt so real", "just made sense", "bounced off the walls"
+  ],
+
+  "interjections": [
+    "(laughs) I couldn’t believe it!",
+    "No way! (claps)",
+    "That made my day, (laughs).",
+    "(chuckle)... You have no idea!",
+    "(whistles) Honestly, amazing!",
+    "So good! (laughs)",
+    "It was perfect — (applause).",
+    "(laughs) Pure joy!",
+    "Absolutely loved it! (claps)",
+    "Couldn’t stop grinning! (chuckle)",
+    "Wow! (whistles)",
+    "(laughs) This lit me up!",
+    "(whistles)... Just yes!",
+    "Loved every second! (laughs)",
+    "(chuckle) Total happiness!",
+    "It hit perfectly! (whistles)",
+    "(laughs) I’m smiling again.",
+    "Everything clicked — (claps)!",
+    "I was glowing... (humming)"
+  ],
+
+  "contexts": [
+    "(laughs)... and I couldn’t stop smiling!",
+    "and everything felt lighter (exhales).",
+    "and I didn’t want it to end — (sighs).",
+    "(whistles) and I wanted to dance!",
+    "(laughs) and I couldn’t stop laughing!",
+    "and the room lit up — (claps)!",
+    "and I held onto it all day... (humming)",
+    "and it made my week! (laughs)",
+    "and I smiled without even realizing (chuckle).",
+    "and I was so full of energy (humming)!",
+    "and I felt so free... (exhales)",
+    "and nothing else mattered.",
+    "and I just wanted to share it (laughs)!",
+    "(laughs) and I laughed until my sides hurt!",
+    "and I couldn’t stop replaying it (whistles)...",
+    "and I felt ten pounds lighter (exhales)!",
+    "and the moment sparkled (humming)...",
+    "and I forgot all the stress — (sighs)",
+    "and I hugged them tight!",
+    "and I just soaked it in... (exhales)",
+    "and it made everything worth it! (laughs)",
+    "(inhales) and I breathed it in.",
+    "and it stayed with me (whistles)...",
+    "and it was everything I needed (sighs).",
+    "and I danced a little inside (whistles)!",
+    "and I caught myself smiling later (chuckle).",
+    "and I said “finally!” (laughs)",
+    "and my heart felt full (humming).",
+    "and I couldn’t stop giggling (laughs)!",
+    "and I felt alive again (exhales).",
+    "and I whispered “yes!” (whistles).",
+    "and I high‑fived the air (claps)!",
+    "and I had the biggest grin (chuckle)!",
+    "and it lifted the whole moment (laughs).",
+    "and the day turned golden (whistles)...",
+    "and the silence was perfect — (sighs).",
+    "and I was glowing (humming)!",
+    "and I bounced around (laughs)!",
+    "and the sun seemed brighter (whistles)!",
+    "and even coffee tasted better (chuckle)...",
+    "and it made everything okay (sighs).",
+    "and I had happy tears (laughs)...",
+    "and I just twirled (whistles)!",
+    "and I hugged myself (humming).",
+    "(laughs) and I laughed out loud in public!",
+    "and it gave me wings (whistles)...",
+    "and I wanted to bottle that feeling (humming).",
+    "(humming)... and I hummed without thinking!",
+    "and I sent five heart emojis (claps).",
+    "and I didn’t need words (exhales)...",
+    "and I knew it was real (sighs).",
+    "and I just sat in the joy (exhales).",
+    "and it filled the room (laughs)!",
+    "and I felt carried (humming)...",
+    "and I danced in my chair (whistles)!",
+    "and it echoed in my bones (humming).",
+    "and I forgot why I was sad (exhales)...",
+    "and I thanked the moment (laughs).",
+    "and I could finally breathe (exhales)!",
+    "and I turned up the music (singing)!",
+    "and I felt hugged (humming).",
+    "and I danced barefoot (whistles)...",
+    "and I made a goofy face (laughs).",
+    "and I felt so warm (exhales).",
+    "and I cried happy tears (laughs)!",
+    "and I replayed it in my head (chuckle).",
+    "and I couldn’t believe it (gasps)!",
+    "and I wanted to freeze time (sighs)...",
+    "and I smiled at a stranger (laughs).",
+    "and I whispered “thank you.” (sighs)",
+    "and I let myself laugh (laughs)!",
+    "and I felt like a kid again (whistles).",
+    "and I laughed‑snorted (laughs)!",
+    "and I leaned into it (exhales)...",
+    "and I closed my eyes and smiled (humming).",
+    "and I sang out loud (singing)!",
+    "and it gave me joy to spare (laughs)...",
+    "and I did a little spin (whistles)!",
+    "and I raised my hands — (claps)!",
+    "(claps)... and I clapped again!",
+    "and I wanted to shout it (laughs)!",
+    "and I texted five people (chuckle).",
+    "and I smiled like an idiot (laughs)!",
+    "and I started dancing (whistles)!",
+    "and I breathed deep and smiled (exhales).",
+    "and I grinned the rest of the day (laughs)!",
+    "and I fist‑pumped the air (claps)!"
+  ],
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}, {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} just... {v}. {c}.",
+    "{i} — {s} {v}, {c}.",
+    "{s} {v}. I smiled so hard. {c}.",
+    "It was simple: {s} {v}. {c}.",
+    "And there it was: {s} {v}. {c}.",
+    "I couldn’t stop smiling — {s} {v}, {c}.",
+    "{s} {v}, and I laughed like a child. {c}.",
+    "It all made sense when {s} {v}. {c}.",
+    "You wouldn’t believe it: {s} {v}, {c}."
+  ]
+}

emotion_templates/neutral.json

@@ -0,0 +1,97 @@
+{
+  "subjects": [
+    "The meeting", "This email", "The weather", "My schedule", "The report",
+    "The file", "The documents", "The update", "The list", "The package",
+    "That call", "The deadline", "My calendar", "The appointment", "The client",
+    "The system", "The form", "The issue", "The request", "This link",
+    "The procedure", "That number", "The login", "The ticket", "The reminder",
+    "The message", "The time", "The place", "The project", "The plan",
+    "The item", "The summary", "The spreadsheet", "The announcement",
+    "The room", "The schedule", "The response", "The folder", "The draft",
+    "The setup", "The chart", "The template", "This section", "The address",
+    "The status", "The link", "The note", "The user", "The change", "The version",
+    "The page", "The setting", "The system log", "The data", "The record",
+    "The feedback", "The form submission", "The result", "The agenda", "The channel",
+    "The section", "The backend", "The field", "The login screen", "The main page",
+    "The recent edit", "The input", "The draft proposal", "The video", "The request form",
+    "The calendar update", "The hour", "The alert", "The setting change", "The comment",
+    "The text box", "The dashboard", "The timezone", "The notification", "The next step",
+    "The change log", "The ping", "The tool", "The auto-reply", "The file name",
+    "The browser tab", "The screen", "The online form", "The number of users",
+    "The archive", "The post", "The backend tool", "The session", "The queue",
+    "The timestamp", "The log", "The script", "The recent call", "The API endpoint",
+    "The shortcut", "The current state", "The setting value", "The message ID"
+  ],
+  "verbs": [
+    "was updated", "was received", "was sent", "is scheduled", "was delivered",
+    "was attached", "is listed", "is included", "is available", "was confirmed",
+    "is submitted", "was opened", "is set", "was approved", "was completed",
+    "was reviewed", "was filed", "is noted", "was mentioned", "was discussed",
+    "was forwarded", "was generated", "was uploaded", "was located", "was exported",
+    "was restarted", "was removed", "was closed", "was fixed", "is resolved",
+    "is visible", "was highlighted", "was added", "was changed", "was renamed",
+    "was stored", "was marked", "was tracked", "was logged", "was selected",
+    "was unchecked", "is prefilled", "is functional", "was muted", "was flagged",
+    "was logged again", "was copied", "was moved", "was parsed", "was captured",
+    "was identified", "was tested", "was analyzed", "was displayed", "was found",
+    "was active", "was paused", "was finalized", "was shared", "was cleared",
+    "was replaced", "was validated", "was reloaded", "was timed out", "was confirmed again",
+    "was repeated", "was archived", "was restarted", "was merged", "was commented on",
+    "was clicked", "was created", "was auto-saved", "was viewed", "was hidden",
+    "was unchecked", "was dismissed", "was shortened", "was synced", "was noted again",
+    "was converted", "was reapproved", "was minimized", "was restored", "was synced again",
+    "was edited", "was translated", "was resized", "was expanded", "was called in",
+    "was reentered", "was backed up", "was counted", "was referenced", "was linked"
+  ],
+  "contexts": [
+    "and noted accordingly", "as expected", "without any issues", "for review",
+    "and is ready", "based on the plan", "according to the request",
+    "and marked complete", "for reference", "with no delay",
+    "and synced properly", "as part of the update", "and stored correctly",
+    "and reviewed again", "without error", "as per instructions",
+    "and appears consistent", "with the rest of the files", "in the system",
+    "as mentioned earlier", "without further input", "at the same time",
+    "on the main screen", "in the report summary", "in the log", "as scheduled",
+    "and is linked correctly", "with updated fields", "as noted", "with default settings",
+    "on the dashboard", "in the latest build", "with minor differences",
+    "with unchanged parameters", "based on previous input", "in the final draft",
+    "in the archive", "and visible now", "within limits", "with expected output",
+    "as per the instructions", "without manual entry", "without formatting issues",
+    "with default layout", "with no duplicates", "and updated again",
+    "with no change required", "on the same page", "with standard formatting",
+    "in the initial pass", "in the preview", "on request", "under normal load",
+    "with corrected values", "in current use", "in the test environment",
+    "with current permissions", "after the last restart", "on page load",
+    "in the dropdown list", "after refresh", "with no visible difference",
+    "under the given conditions", "within tolerance", "for later reference",
+    "during the last session", "on confirmation", "as of now", "as reviewed",
+    "without alert", "and is part of the bundle", "without recent changes",
+    "on repeated use", "in line with policy", "and saved successfully",
+    "in its original format", "with logged history", "from default mode",
+    "and loaded correctly", "with stable results", "with current context",
+    "during the trial", "in admin view", "in preview mode", "from last session"
+  ],
+  "interjections": [
+    "Okay", "Sure", "All right", "Understood", "Makes sense",
+    "Got it", "Thanks", "No problem", "Noted", "All good",
+    "Sounds fine", "Looks okay", "That works", "Cool", "Done",
+    "Let me check", "Confirmed", "Updated", "Logged", "As expected"
+  ],
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}, {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{i}. {s} {v}, {c}.",
+    "Just FYI: {s} {v}, {c}.",
+    "Note: {s} {v}, {c}.",
+    "{s} {v}. No further action required.",
+    "Update: {s} {v}, {c}.",
+    "For reference, {s} {v}.",
+    "Also, {s} {v}.",
+    "{s} {v} as planned. {c}."
+  ]
+}

emotion_templates/sad.json

@@ -0,0 +1,183 @@
+{
+  "subjects": [
+    "That memory", "This feeling", "Her silence", "His voice", "The goodbye",
+    "That call", "This day", "My past", "That old photo", "The message",
+    "What she said", "What he didn’t say", "The look in their eyes", "That time of year",
+    "The room we used to share", "That place", "The last conversation", "That empty chair",
+    "That letter", "The moment I knew", "That one decision", "The song we both liked",
+    "My mistake", "Her absence", "The words I never said", "The things I lost",
+    "The silence after", "His last text", "My regret", "That broken promise",
+    "That question", "The goodbye hug", "The final message", "The void", "The shadow of it all",
+    "My own thoughts", "The long nights", "That walk alone", "Her last smile",
+    "That feeling of loss", "The unread message", "The sound of her name", "The forgotten laugh",
+    "The unspoken words", "This moment", "The fading photo", "The conversation that never came",
+    "The look I still remember", "The missed call", "This quiet", "What we never had",
+    "His empty side", "The empty inbox", "The things left unsaid", "The cracked frame",
+    "That empty promise", "The silence in the car", "The distance", "The space between us",
+    "The moment everything changed", "The unmade bed", "This weight", "The last gift",
+    "The things I should’ve done", "This cold air", "That long pause", "The truth I denied",
+    "The tears I hid", "The smile I faked", "The echo in my chest", "The memories flooding back",
+    "The half-empty cup", "That slow fade", "That goodbye text", "The waiting",
+    "That unanswered question", "This morning", "His coat", "The words on the page",
+    "That familiar place", "The night we stopped talking", "The unread letters",
+    "The unsent messages", "That photo on my phone", "That song I can’t skip",
+    "That cold seat", "The quiet kitchen", "The dim light", "That empty room",
+    "The thing I never said", "The end", "That hallway", "The couch we sat on",
+    "The words that hurt", "The moment we broke", "That one night", "The feeling of being left",
+    "What I carry", "That date", "The thing I remember most", "The after"
+  ],
+  "verbs": [
+    "still hurts", "breaks me", "keeps me awake", "never fades", "hits me hard",
+    "leaves me numb", "crushed me", "stays with me", "burns inside", "tears me apart",
+    "weighs on me", "makes me cry", "won’t let go", "haunts me", "hurts deeply",
+    "shatters me", "lingers", "cuts deep", "took a part of me", "sits heavy in my chest",
+    "aches quietly", "feels endless", "never really left", "drowns me", "pulls me down",
+    "brings tears", "holds me still", "makes my chest heavy", "chills me",
+    "drains me", "fills me with sorrow", "leaves a mark", "empties me", "blurs everything",
+    "mutes my world", "dims my light", "echoes loudly", "steals my breath",
+    "closes my throat", "breaks the silence", "pushes me down", "holds me back",
+    "reminds me", "sticks like glue", "crawls under my skin", "hangs over me",
+    "wraps around me", "dampens everything", "stings", "feels like drowning",
+    "pulls at my heart", "sinks deep", "won’t leave", "burns behind my eyes",
+    "won’t let me forget", "drags on", "never ends", "feels permanent",
+    "presses on my chest", "washes over me", "never gets easier", "finds me in the quiet",
+    "catches me off guard", "unravels me", "pours in like rain", "sits in my lungs",
+    "breaks the morning", "bleeds into my days", "clouds my thoughts", "chokes me softly",
+    "grips my stomach", "twists my mind", "sinks into my bones", "grays out the world",
+    "softens my voice", "shadows my smile", "brings a wave", "holds my breath",
+    "dims the sun", "keeps repeating", "echoes through", "shuts me down",
+    "darkens the room", "muffles everything", "screams inside", "keeps me from moving",
+    "follows me", "closes in", "blurs my days", "fogs my memory", "empties the joy",
+    "clutches my chest", "keeps showing up", "presses into me", "sits beside me",
+    "floods my eyes", "weighs down my steps", "never softens", "never truly heals"
+  ],
+  "interjections": [
+    "(sighs)... I still can't believe it.",
+    "Some things never leave (sniffs).",
+    "(mumbles) Honestly...",
+    "(exhales) It just hurts.",
+    "I wish I could say it (sighs)...",
+    "If only they knew (inhales)...",
+    "(clears throat) No one sees it.",
+    "Deep down (sniffs)...",
+    "Truth is — (sighs) I’m still there.",
+    "Even now... (exhales)",
+    "(mumbles) I never said it.",
+    "(sniffs)... It stays with me.",
+    "Sometimes I wonder (sighs)...",
+    "I still carry it (exhales).",
+    "To this day — (sniffs) it aches.",
+    "(sighs) I remember everything.",
+    "Some pain doesn’t show (mumbles)...",
+    "Even in silence (exhales)...",
+    "That moment still plays (sniffs).",
+    "And yet I smile (sighs)..."
+  ],
+
+  "contexts": [
+    "(sighs)... and I can’t move on.",
+    "like nothing will ever be the same (exhales).",
+    "and I keep holding it in (sniffs)...",
+    "though no one sees it (sighs).",
+    "and I hide it so well (inhales)...",
+    "and I still feel it all (exhales).",
+    "and I smile like I’m fine (mumbles)...",
+    "though I’m breaking inside (sighs).",
+    "but I never talk about it (sniffs).",
+    "and it follows me everywhere (exhales)...",
+    "and I still carry it (sighs)...",
+    "like it just happened (inhales).",
+    "and I don’t know how to forget (exhales)...",
+    "and no one knows the weight (sighs).",
+    "even when I laugh (sniffs)...",
+    "and it feels so unfair (exhales).",
+    "and it still ruins me (sighs)...",
+    "and I feel it every day (inhales).",
+    "but I try to act normal (mumbles)...",
+    "like I’m supposed to be okay (sighs).",
+    "and I never got closure (exhales)...",
+    "and I miss them every day (sniffs).",
+    "but the pain stays the same (sighs)...",
+    "and it’s always right there (exhales).",
+    "and it floods me suddenly (sniffs)...",
+    "and it breaks me in pieces (sighs).",
+    "and I hear the echo of it (exhales)...",
+    "and I wish I said more (sighs).",
+    "and I regret staying quiet (mumbles)...",
+    "and I feel so small (sniffs).",
+    "and I can’t stop thinking about it (exhales)...",
+    "and I just collapse (sighs).",
+    "and I keep blaming myself (inhales)...",
+    "but it wasn’t even my fault (exhales).",
+    "and I replay it over and over (sighs)...",
+    "and it plays like a movie (sniffs).",
+    "but I never stop hurting (exhales)...",
+    "and I keep pretending (sighs).",
+    "and no one asks (mumbles)...",
+    "and I hate that it’s still here (exhales).",
+    "but I can’t let it go (sighs)...",
+    "even when I want to (sniffs).",
+    "and I can’t breathe sometimes (exhales)...",
+    "and my chest aches quietly (sighs).",
+    "and it keeps resurfacing (sniffs)...",
+    "and I’m so tired of it (exhales).",
+    "and I don’t know how to heal (sighs)...",
+    "and it knocks the wind out of me (exhales).",
+    "and I feel like a ghost (sighs)...",
+    "and I smile while breaking (mumbles).",
+    "and I don’t talk about it anymore (sniffs)...",
+    "and I wake up with it (exhales).",
+    "and it seeps into everything (sighs)...",
+    "and I lost myself there (exhales).",
+    "but no one notices (sighs)...",
+    "and I keep it locked up (sniffs).",
+    "and I carry it alone (exhales)...",
+    "and it’s always just under the surface (sighs).",
+    "but I’m still hurting (exhales)...",
+    "and it’s louder in the silence (sighs).",
+    "and I fall apart slowly (sniffs)...",
+    "and I can’t fix it (exhales).",
+    "and I still wait for them (sighs)...",
+    "and it all feels empty (exhales).",
+    "and it doesn’t make sense (sighs)...",
+    "but I can’t forget (sniffs).",
+    "and it makes me feel hollow (exhales)...",
+    "but I carry on anyway (sighs).",
+    "and I whisper it to no one (mumbles)...",
+    "and I miss who I was (exhales).",
+    "and I don’t think it’ll ever stop (sighs)...",
+    "and it comes back at night (sniffs).",
+    "and it makes me feel cold (exhales)...",
+    "but I still try to be okay (sighs).",
+    "and I hate talking about it (inhales)...",
+    "and I still cry when I’m alone (sniffs).",
+    "and I lose words (sighs)...",
+    "and I feel fragile (exhales).",
+    "and it’s exhausting (sighs)...",
+    "but I just nod and smile (mumbles).",
+    "and it feels like I’m fading (exhales)...",
+    "and it eats away at me (sighs).",
+    "but I say nothing (sniffs)...",
+    "and I hope they never see (sighs).",
+    "and I fake my way through (exhales)...",
+    "but I’m breaking slowly (sighs)."
+  ],
+
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}, {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} still... {v}. {c}.",
+    "{s} {v}. And it never ends. {c}.",
+    "I try to forget, but {s} {v}, {c}.",
+    "{i} — {s} {v}, {c}.",
+    "{s} {v}. {i}. {c}.",
+    "The truth is, {s} {v}.",
+    "‘{s} {v}’ — and no one knew. {c}.",
+    "{s} just doesn’t go away. {c}.",
+    "Even now, {s} {v}, {c}."
+  ]
+}

emotion_templates/surprise.json

@@ -0,0 +1,198 @@
+{
+  "subjects": [
+    "That message", "This call", "The result", "What she said", "The announcement",
+    "The coincidence", "The gift", "His answer", "Her reaction", "The timing",
+    "That moment", "The photo", "This discovery", "The unexpected reply",
+    "The look on his face", "The email", "That visit", "The headline",
+    "The glitch", "This outcome", "The news", "That thing", "The realization",
+    "Her arrival", "His silence", "That sound", "That noise", "The blink",
+    "This miracle", "The coincidence of dates", "The surprise guest",
+    "The reversed roles", "This twist", "The window", "The echo", "The light",
+    "The turning point", "The expression", "The instant reply", "The notification",
+    "This random thing", "The unexpected gift", "The open door", "That trigger",
+    "The unlocked phone", "The old message", "That letter", "The voicemail",
+    "The opportunity", "The moment of silence", "The call from nowhere",
+    "The found photo", "That chance meeting", "What I saw", "The change in tone",
+    "The open drawer", "The sound in the hallway", "The empty room",
+    "The random response", "Her sudden shift", "The blinking lights",
+    "What he did", "That conversation", "The unplanned moment", "The whisper",
+    "That sudden feeling", "That name", "This vibe", "That expression",
+    "The door creaking", "The unexpected question", "The win", "This strange timing",
+    "The unplugged cable", "The room's silence", "The laugh", "The pause",
+    "The sudden music", "The uninvited guest", "The news headline", "The page turn",
+    "The camera flash", "The unknown voice", "The stray animal", "The forgotten date",
+    "That coincidence", "The twisted sentence", "That eye contact", "This strange sound",
+    "The falling object", "The flicker", "The joke", "That mood shift", "This noise",
+    "The silent phone", "That little thing", "The hidden truth", "The strange smile"
+  ],
+  "verbs": [
+    "shocked me", "made me freeze", "caught me off guard", "left me speechless",
+    "blew my mind", "came out of nowhere", "was totally unexpected", "made my jaw drop",
+    "felt surreal", "threw me off", "turned everything around", "changed the whole vibe",
+    "reset the tone", "hit me like lightning", "flipped the moment", "was unreal",
+    "was bizarre", "seemed impossible", "was both funny and scary", "made me pause",
+    "rewired my brain", "was absurd", "challenged everything I thought", "was chaotic",
+    "made no sense", "was random", "came with no warning", "felt like a dream",
+    "sparked confusion", "was like fiction", "shattered expectations", "reversed my mood",
+    "surprised everyone", "felt impossible", "disrupted everything", "popped up suddenly",
+    "turned heads", "was pure surprise", "hit like a flash", "flipped the whole thing",
+    "triggered laughter", "was hilariously off", "felt like a glitch", "reset the energy",
+    "dropped like a bomb", "silenced the room", "was a twist", "stood out completely",
+    "just happened", "was nonsense", "was oddly fitting", "was genius", "twisted my logic",
+    "shook everyone", "sparked wild reactions", "caught all attention", "stunned me",
+    "was beautifully weird", "was madness", "reversed all logic", "was insane",
+    "left us reeling", "had no explanation", "felt electric", "hit mid-sentence",
+    "made me sit up", "just flipped it", "was comedic", "was magical", "reset my brain",
+    "was silly and scary", "snapped everything", "twisted expectations", "felt improvised",
+    "landed unexpectedly", "snuck up on us", "was so weird", "broke the silence",
+    "sparked awe", "felt foreign", "felt glitched", "confused everyone", "was strangely real",
+    "made me react instantly", "was unexpected chaos", "took a wild turn", "made no sense at all",
+    "came suddenly", "hit without logic", "felt reversed", "cut through everything",
+    "changed the pace", "felt timed perfectly", "felt unscripted", "just crashed in",
+    "was the last thing I thought", "bent the moment", "came sharply", "felt like a prank"
+  ],
+  "interjections": [
+    "(gasps) Honestly?!",
+    "No way — (laughs)!",
+    "Wait... what? (gasps)",
+    "(inhales) Seriously—",
+    "Oh wow! (whistles)",
+    "You're kidding! (laughs)",
+    "(gasps) I can't believe it!",
+    "What just happened? (chuckle)",
+    "Believe it or not — (gasps)",
+    "Suddenly... (laughs)",
+    "(whistles) Guess what!",
+    "Right then — (gasps) boom!",
+    "Out of nowhere (laughs)!",
+    "Just like that... (gasps)",
+    "Then — bam! (chuckle)",
+    "(gasps) Without warning!",
+    "For real? (laughs)",
+    "You won't believe this! (gasps)",
+    "Hold up— (whistles)!",
+    "(claps) That just happened!"
+  ],
+
+  "contexts": [
+    "(gasps)... and I didn’t know what to say!",
+    "and everyone froze — (exhales).",
+    "and I had to laugh (laughs)!",
+    "and I still don’t get it... (chuckle)",
+    "and it felt surreal (whistles).",
+    "and no one moved — (inhales).",
+    "(gasps) and I just... gasped again.",
+    "and I was speechless (exhales)...",
+    "and I blinked like five times (gasps).",
+    "and it echoed in my head — (whistles)",
+    "and everyone just stared (inhales)...",
+    "and I sat there stunned (gasps)!",
+    "and the room went silent — (exhales).",
+    "and we all looked around (chuckle)...",
+    "and I looked twice (gasps)!",
+    "and I was like “what?!” (laughs)",
+    "and I couldn’t believe it (exhales)...",
+    "and it stuck with me (whistles).",
+    "and I still think about it (gasps)...",
+    "and I just shook my head (laughs).",
+    "and it broke the tension — (chuckle)!",
+    "and it threw off everything (exhales)...",
+    "and I said “no way!” (gasps)",
+    "and we all cracked up (laughs)!",
+    "and the vibe was gone — (inhales).",
+    "and it changed the day (whistles)...",
+    "and I had to rewind (gasps)!",
+    "and my jaw dropped — (exhales).",
+    "and I froze (gasps)...",
+    "and we all lost it (laughs)!",
+    "and it messed me up (chuckle)...",
+    "and I just stood still (inhales).",
+    "and I had no words (gasps)...",
+    "and we laughed for a minute (laughs).",
+    "and it felt like a dream — (whistles)...",
+    "and I blinked in shock (gasps)!",
+    "and we all paused (exhales)...",
+    "and I just stared (gasps)...",
+    "and I couldn’t speak (inhales).",
+    "and the shift was instant (gasps)!",
+    "and it was hilarious (laughs).",
+    "and my brain glitched (chuckle)...",
+    "and everyone panicked slightly (gasps).",
+    "and I had chills (inhales)...",
+    "and it just... happened (exhales).",
+    "and it triggered everything (gasps)!",
+    "and I remember the silence (whistles)...",
+    "and someone whispered “what just happened?” (gasps)",
+    "and we all froze (inhales)...",
+    "and we burst out laughing (laughs)!",
+    "and it flipped the room — (whistles)!",
+    "and I had to sit (gasps)...",
+    "and it made no sense (chuckle).",
+    "and I gasped loudly (gasps)!",
+    "and everyone blinked (inhales)...",
+    "and I had to walk out (exhales).",
+    "and the energy just changed (whistles)...",
+    "and it felt like fiction (gasps).",
+    "and the moment stuck — (exhales)...",
+    "and I tried to process it (chuckle).",
+    "and I said nothing (gasps)...",
+    "and the response was just shock (inhales).",
+    "and I heard my own heartbeat (exhales)...",
+    "and we just blinked (gasps).",
+    "and it rewrote the mood (whistles)...",
+    "and it still plays in my head (gasps)...",
+    "and it made the silence louder (exhales).",
+    "and I had to sit down (inhales)...",
+    "and it just hit me (gasps)!",
+    "and the air shifted — (whistles)...",
+    "and it startled me (gasps).",
+    "and everyone had the same face (chuckle)...",
+    "and I was out of words (exhales).",
+    "and someone gasped (gasps)!",
+    "and the tension cracked (laughs)...",
+    "and it made me laugh hard (laughs)!",
+    "and we all paused and stared (inhales)...",
+    "and I just looked down (exhales).",
+    "and we replayed it in our heads (whistles)...",
+    "and no one said a word (gasps).",
+    "and the timing was wild — (laughs)!",
+    "and it was too real (inhales)...",
+    "and we couldn’t stop laughing (laughs)!",
+    "and I shook my head slowly (chuckle)...",
+    "and it crashed everything (gasps).",
+    "and I wanted to rewind it (exhales)...",
+    "and it threw the moment off (inhales).",
+    "and we sat in silence (gasps)...",
+    "and my eyes went wide (exhales).",
+    "and it stunned everyone (gasps)!",
+    "and it landed like a bomb (laughs).",
+    "and I burst out mid‑thought (chuckle)...",
+    "and it shattered logic (gasps).",
+    "and I couldn’t unsee it (exhales)...",
+    "and the shift was visible (whistles).",
+    "and we blinked hard (gasps)..."
+  ],
+
+  "templates": [
+    "{s} {v}, {c}.",
+    "{i}! {s} {v}.",
+    "{s} {v}. {c}.",
+    "{s} {v} — {c}.",
+    "{c}. {s} {v}.",
+    "{s}. It {v}, {c}.",
+    "{s} just... {v}. {c}.",
+    "You won’t believe this: {s} {v}, {c}!",
+    "And then, {s} {v}. {c}.",
+    "‘{s} {v}?’ That’s what happened. {c}.",
+    "{i}! — {s} {v}, {c}!",
+    "Everyone was quiet. Then {s} {v}, {c}!",
+    "{s} {v}. {i}! {c}.",
+    "{s} {v}. Can you imagine?! {c}.",
+    "So random: {s} {v}, {c}.",
+    "Boom! {s} {v}, {c}!",
+    "Suddenly, {s} {v}! {c}.",
+    "{s} {v} like a lightning bolt! {c}.",
+    "I blinked and {s} {v}! {c}.",
+    "Out of thin air — {s} {v}! {c}."
+  ]
+}

generate_emotion_texts_dataset.py

@@ -0,0 +1,137 @@
+import json
+import random
+import pandas as pd
+import re
+from datetime import timedelta
+from pathlib import Path
+
+# === Загрузка шаблонов ===
+def load_templates_json(templates_dir, emotion):
+    path = Path(templates_dir) / f"{emotion}.json"
+    if not path.exists():
+        raise FileNotFoundError(f"Шаблон для эмоции '{emotion}' не найден: {path}")
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+# === Генерация текстов с учётом seed и антидубликатов ===
+def generate_emotion_batch(n, template_data, seed=None):
+    if seed is not None:
+        random.seed(seed)
+
+    subjects       = template_data["subjects"]
+    verbs          = template_data["verbs"]
+    contexts       = template_data["contexts"]
+    interjections  = template_data.get("interjections", [""])
+    templates      = template_data["templates"]
+
+    # Допустимые звуковые метки DIA‑TTS
+    dia_tags = {
+        "(laughs)", "(clears throat)", "(sighs)", "(gasps)", "(coughs)",
+        "(singing)", "(sings)", "(mumbles)", "(beep)", "(groans)", "(sniffs)",
+        "(claps)", "(screams)", "(inhales)", "(exhales)", "(applause)",
+        "(burps)", "(humming)", "(sneezes)", "(chuckle)", "(whistles)"
+    }
+
+    def has_tag(text):      return any(tag in text for tag in dia_tags)
+    def remove_tags(text):
+        for tag in dia_tags:
+            text = text.replace(tag, "")
+        return text.strip()
+
+    phrases, attempts = set(), 0
+    max_attempts = n * 50
+
+    while len(phrases) < n and attempts < max_attempts:
+        s, v = random.choice(subjects), random.choice(verbs)
+        c, i = random.choice(contexts), random.choice(interjections)
+        t     = random.choice(templates)
+
+        # ▸ Разрешаем максимум одну звуковую метку на фразу
+        if has_tag(i) and has_tag(c):
+            if random.random() < .5:
+                c = remove_tags(c)
+            else:
+                i = remove_tags(i)
+
+        phrase = t.format(s=s, v=v, c=c, i=i)
+
+        # --- Очистка без разрушения многоточий ---------------------------
+        # 1) убрать пробелы перед знаками пунктуации
+        phrase = re.sub(r"\s+([,.!?])", r"\1", phrase)
+        # 2) превратить двойную точку, КОТОРАЯ не часть троеточия, в одну
+        phrase = re.sub(r"(?<!\.)\.\.(?!\.)", ".", phrase)
+        # 3) вставить пробел, если после метки сразу идёт слово
+        phrase = re.sub(r"\)(?=\w)", ") ", phrase)
+        # 4) схлопнуть множественные пробелы и обрезать края
+        phrase = re.sub(r"\s{2,}", " ", phrase).strip()
+        # ------------------------------------------------------------------
+
+        if phrase not in phrases:
+            phrases.add(phrase)
+        attempts += 1
+
+    if len(phrases) < n:
+        print(f"⚠️ Только {len(phrases)} уникальных фраз из {n} запрошенных — возможно, исчерпан пул шаблонов.")
+
+    return list(phrases)
+
+# === Генерация временных меток ===
+def generate_dummy_timestamps(n):
+    base_time, result = timedelta(), []
+    for idx in range(n):
+        start = base_time + timedelta(seconds=idx * 6)
+        end   = start + timedelta(seconds=5)
+        result.append((
+            str(start).split(".")[0] + ",000",
+            str(end).split(".")[0]   + ",000"
+        ))
+    return result
+
+# === Финальная сборка и сохранение CSV ===
+def create_emotion_csv(template_path, emotion_label, out_file, n=1000, seed=None):
+    data     = load_templates_json(template_path, emotion_label)
+    phrases  = generate_emotion_batch(n, data, seed)
+    timeline = generate_dummy_timestamps(n)
+
+    emotions   = ["neutral", "happy", "sad", "anger", "surprise", "disgust", "fear"]
+    label_mask = {e: float(e == emotion_label) for e in emotions}
+
+    df = pd.DataFrame({
+        "video_name": [f"dia_{emotion_label}_utt{i}_synt" for i in range(n)],
+        "start_time": [s for s, _ in timeline],
+        "end_time"  : [e for _, e in timeline],
+        "sentiment" : [0] * n,
+        **{e: [label_mask[e]] * n for e in emotions},
+        "text"      : phrases
+    })
+
+    df.to_csv(out_file, index=False)
+    print(f"✅ Сохранено {len(df)} строк → {out_file}")
+
+    # --- Проверка дубликатов ---
+    dupes = df[df.duplicated("text", keep=False)]
+    if not dupes.empty:
+        dupe_file = Path(out_file).with_name(f"duplicates_{emotion_label}.csv")
+        dupes.to_csv(dupe_file, index=False)
+        print(f"⚠️ Найдено {len(dupes)} повторов → {dupe_file}")
+    else:
+        print("✅ Дубликатов нет.")
+
+# === Точка вход�� ===
+if __name__ == "__main__":
+    emotion_config = {
+        "anger":    3600,
+        "disgust":  4438,
+        "fear":     4441,
+        "happy":    2966,
+        "sad":      4026,
+        "surprise": 3504
+    }
+
+    seed, template_path, out_dir = 42, "emotion_templates", "synthetic_data"
+    Path(out_dir).mkdir(parents=True, exist_ok=True)
+
+    for emotion, n in emotion_config.items():
+        out_csv = Path(out_dir) / f"meld_synthetic_{emotion}_{n}.csv"
+        print(f"\n🔄 Генерация: {emotion} ({n} фраз)")
+        create_emotion_csv(template_path, emotion, str(out_csv), n, seed)

generate_synthetic_dataset.py

@@ -0,0 +1,71 @@
+import os
+import logging
+import time
+import pandas as pd
+from multiprocessing import Process
+from synthetic_utils.dia_tts_wrapper import DiaTTSWrapper
+
+
+def process_chunk(chunk_df, emotion, wav_dir, device, chunk_id):
+    tts = DiaTTSWrapper(device=device)
+    for idx, row in chunk_df.iterrows():
+        text = row["text"]
+        video_name = row.get("video_name", f"{emotion}_{chunk_id}_{idx}")
+        filename_prefix = video_name
+
+        try:
+            result = tts.generate_and_save_audio(
+                text=text,
+                out_dir=wav_dir,
+                filename_prefix=filename_prefix,
+                use_timestamp=False,
+                skip_if_exists=True,
+                max_trim_duration=10.0
+            )
+            if result is None:
+                logging.info(f"[{emotion}] ⏭️ Пропущено: {filename_prefix}.wav")
+            else:
+                logging.info(f"[{emotion}] ✔ {filename_prefix}.wav")
+        except Exception as e:
+            logging.error(f"[{emotion}] ❌ Ошибка: {filename_prefix} — {e}")
+
+
+def generate_from_emotion_csv(
+    csv_path: str,
+    emotion: str,
+    output_dir: str,
+    device: str = "cuda",
+    max_samples: int = None,
+    num_processes: int = 1
+):
+    out_dir = os.path.join(output_dir, emotion)
+    wav_dir = os.path.join(out_dir, "wavs")
+    os.makedirs(wav_dir, exist_ok=True)
+
+    logging.info(f"🎙️ Эмоция: '{emotion}' | CSV: {csv_path}")
+    logging.info(f"📥 Сохранение в: {wav_dir}")
+
+    df = pd.read_csv(csv_path)
+    if max_samples is not None:
+        df = df.sample(n=max_samples)
+
+    chunk_size = len(df) // num_processes
+    chunks = [df.iloc[i*chunk_size : (i+1)*chunk_size] for i in range(num_processes)]
+
+    remainder = len(df) % num_processes
+    if remainder > 0:
+        chunks[-1] = pd.concat([chunks[-1], df.iloc[-remainder:]])
+
+    total_start = time.time()
+
+    processes = []
+    for i, chunk in enumerate(chunks):
+        p = Process(target=process_chunk, args=(chunk, emotion, wav_dir, device, i))
+        p.start()
+        processes.append(p)
+
+    for p in processes:
+        p.join()
+
+    total_elapsed = time.time() - total_start
+    logging.info(f"✅ Эмоция '{emotion}' завершена | чанков: {num_processes} | ⏱️ {total_elapsed:.1f} сек\n")

main.py

@@ -0,0 +1,119 @@
+# train.py
+# coding: utf-8
+import logging
+import os
+import shutil
+import datetime
+import whisper
+import toml
+# os.environ["HF_HOME"] = "models"
+
+from utils.config_loader import ConfigLoader
+from utils.logger_setup import setup_logger
+from utils.search_utils import greedy_search, exhaustive_search
+from training.train_utils import (
+    make_dataset_and_loader,
+    train_once
+)
+from data_loading.feature_extractor import PretrainedAudioEmbeddingExtractor, PretrainedTextEmbeddingExtractor
+
+def main():
+
+    #  Грузим конфиг
+    base_config = ConfigLoader("config.toml")
+
+    model_name = base_config.model_name.replace("/", "_").replace(" ", "_").lower()
+    timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
+    results_dir = f"results_{model_name}_{timestamp}"
+    os.makedirs(results_dir, exist_ok=True)
+
+    epochlog_dir = os.path.join(results_dir, "metrics_by_epoch")
+    os.makedirs(epochlog_dir, exist_ok=True)
+
+    # Настраиваем logging
+    log_file = os.path.join(results_dir, "session_log.txt")
+    setup_logger(logging.DEBUG, log_file=log_file)
+
+    #  Грузим конфиг
+    base_config.show_config()
+
+    shutil.copy("config.toml", os.path.join(results_dir, "config_copy.toml"))
+    #  Файл, куда будет писать наш жадный поиск
+    overrides_file = os.path.join(results_dir, "overrides.txt")
+    csv_prefix = os.path.join(epochlog_dir, "metrics_epochlog")
+
+    audio_feature_extractor= PretrainedAudioEmbeddingExtractor(base_config)
+    text_feature_extractor = PretrainedTextEmbeddingExtractor(base_config)
+
+    # Инициализируем Whisper-модель один раз
+    logging.info(f"Инициализация Whisper: модель={base_config.whisper_model}, устройство={base_config.whisper_device}")
+    whisper_model = whisper.load_model(base_config.whisper_model, device=base_config.whisper_device)
+
+    # Делаем датасеты/лоадеры
+    # Общий train_loader
+    _, train_loader = make_dataset_and_loader(base_config, "train", audio_feature_extractor, text_feature_extractor, whisper_model)
+
+    # Раздельные dev/test
+    dev_loaders = []
+    test_loaders = []
+
+    for dataset_name in base_config.datasets:
+        _, dev_loader = make_dataset_and_loader(base_config, "dev",  audio_feature_extractor, text_feature_extractor, whisper_model, only_dataset=dataset_name)
+        _, test_loader = make_dataset_and_loader(base_config, "test",  audio_feature_extractor, text_feature_extractor, whisper_model, only_dataset=dataset_name)
+
+        dev_loaders.append((dataset_name, dev_loader))
+        test_loaders.append((dataset_name, test_loader))
+
+    if base_config.prepare_only:
+        logging.info("== Режим prepare_only: только подготовка данных, без обучения ==")
+        return
+
+    search_config = toml.load("search_params.toml")
+    param_grid = dict(search_config["grid"])
+    default_values = dict(search_config["defaults"])
+
+    if base_config.search_type == "greedy":
+        greedy_search(
+            base_config       = base_config,
+            train_loader      = train_loader,
+            dev_loader        = dev_loaders,
+            test_loader       = test_loaders,
+            train_fn          = train_once,
+            overrides_file    = overrides_file,
+            param_grid        = param_grid,
+            default_values    = default_values,
+            csv_prefix        = csv_prefix
+        )
+
+    elif base_config.search_type == "exhaustive":
+        exhaustive_search(
+            base_config       = base_config,
+            train_loader      = train_loader,
+            dev_loader        = dev_loaders,
+            test_loader       = test_loaders,
+            train_fn          = train_once,
+            overrides_file    = overrides_file,
+            param_grid        = param_grid,
+            csv_prefix        = csv_prefix
+        )
+
+    elif base_config.search_type == "none":
+        logging.info("== Режим одиночной тренировки (без поиска параметров) ==")
+
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        csv_file_path = f"{csv_prefix}_single_{timestamp}.csv"
+
+        train_once(
+            config           = base_config,
+            train_loader     = train_loader,
+            dev_loaders      = dev_loaders,
+            test_loaders     = test_loaders,
+            metrics_csv_path = csv_file_path
+        )
+
+    else:
+        raise ValueError(f"⛔️ Неверное значение search_type в конфиге: '{base_config.search_type}'. Используй 'greedy', 'exhaustive' или 'none'.")
+
+
+if __name__ == "__main__":
+    main()

models/help_layers.py

@@ -0,0 +1,528 @@
+# coding: utf-8
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.nn.init as init
+import numpy as np
+import math
+from torch.nn.functional import silu
+from torch.nn.functional import softplus
+from einops import rearrange, einsum
+from torch import Tensor
+from torch_geometric.nn import GATConv, RGCNConv, TransformerConv
+
+class PositionWiseFeedForward(nn.Module):
+    def __init__(self, input_dim, hidden_dim, dropout=0.1):
+        super().__init__()
+        self.layer_1 = nn.Linear(input_dim, hidden_dim)
+        self.layer_2 = nn.Linear(hidden_dim, input_dim)
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x):
+        x = self.layer_1(x)
+        x = F.gelu(x)  # Более плавная активация
+        x = self.dropout(x)
+        return self.layer_2(x)
+
+
+class AddAndNorm(nn.Module):
+    def __init__(self, input_dim, dropout=0.1):
+        super().__init__()
+        self.norm = nn.LayerNorm(input_dim)
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, residual):
+        return self.norm(x + self.dropout(residual))
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
+        pe = torch.zeros(max_len, d_model)
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+
+        self.register_buffer("pe", pe)
+
+    def forward(self, x):
+        x = x + self.pe[: x.size(1)].detach()  # Отключаем градиенты
+        return self.dropout(x)
+
+
+class TransformerEncoderLayer(nn.Module):
+    def __init__(self, input_dim, num_heads, dropout=0.1, positional_encoding=False):
+        super().__init__()
+        self.input_dim = input_dim
+        self.self_attention = nn.MultiheadAttention(input_dim, num_heads, dropout=dropout, batch_first=True)
+        # self.self_attention = MHA(
+        #     embed_dim=input_dim,
+        #     num_heads=num_heads,
+        #     dropout=dropout,
+        #     # bias=True,
+        #     use_flash_attn=True
+        # )
+        self.feed_forward = PositionWiseFeedForward(input_dim, input_dim, dropout=dropout)
+        self.add_norm_after_attention = AddAndNorm(input_dim, dropout=dropout)
+        self.add_norm_after_ff = AddAndNorm(input_dim, dropout=dropout)
+        self.positional_encoding = PositionalEncoding(input_dim) if positional_encoding else None
+
+    def forward(self, key, value, query):
+        if self.positional_encoding:
+            key = self.positional_encoding(key)
+            value = self.positional_encoding(value)
+            query = self.positional_encoding(query)
+
+        attn_output, _ = self.self_attention(query, key, value, need_weights=False)
+        # attn_output = self.self_attention(query, key, value)
+
+        x = self.add_norm_after_attention(attn_output, query)
+
+        ff_output = self.feed_forward(x)
+        x = self.add_norm_after_ff(ff_output, x)
+
+        return x
+
+class GAL(nn.Module):
+    def __init__(self, input_dim_F1, input_dim_F2, gated_dim, dropout_rate):
+        super(GAL, self).__init__()
+
+        self.WF1 = nn.Parameter(torch.Tensor(input_dim_F1, gated_dim))
+        self.WF2 = nn.Parameter(torch.Tensor(input_dim_F2, gated_dim))
+
+        init.xavier_uniform_(self.WF1)
+        init.xavier_uniform_(self.WF2)
+
+        dim_size_f = input_dim_F1 + input_dim_F2
+
+        self.WF = nn.Parameter(torch.Tensor(dim_size_f, gated_dim))
+
+        init.xavier_uniform_(self.WF)
+
+        self.dropout = nn.Dropout(dropout_rate)
+
+    def forward(self, f1, f2):
+
+        h_f1 = self.dropout(torch.tanh(torch.matmul(f1, self.WF1)))
+        h_f2 = self.dropout(torch.tanh(torch.matmul(f2, self.WF2)))
+        # print(h_f1.shape, h_f2.shape, self.WF.shape, torch.cat([f1, f2], dim=1).shape)
+        z_f = torch.softmax(self.dropout(torch.matmul(torch.cat([f1, f2], dim=1), self.WF)), dim=1)
+        h_f = z_f*h_f1 + (1 - z_f)*h_f2
+        return h_f
+
+class GraphFusionLayer(nn.Module):
+    def __init__(self, hidden_dim, dropout=0.0, heads=2, out_mean=True):
+        super().__init__()
+        self.out_mean = out_mean
+        # # Проекционные слои для признаков
+        self.proj_audio = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+        self.proj_text = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Графовые слои
+        self.gat1 = GATConv(hidden_dim, hidden_dim, heads=heads)
+        self.gat2 = GATConv(hidden_dim*heads, hidden_dim)
+
+        # Финальная проекция
+        self.fc = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+    def build_complete_graph(self, num_nodes):
+        # Создаем полный граф (каждый узел соединен со всеми)
+        edge_index = []
+        for i in range(num_nodes):
+            for j in range(num_nodes):
+                if i != j:
+                    edge_index.append([i, j])
+        return torch.tensor(edge_index).t().contiguous()
+
+    def forward(self, audio_stats, text_stats):
+        """
+        audio_stats: [batch_size, hidden_dim]
+        text_stats: [batch_size, hidden_dim]
+        """
+        batch_size = audio_stats.size(0)
+
+        # Проекция признаков
+        x_audio = F.relu(self.proj_audio(audio_stats))  # [batch_size, hidden_dim]
+        x_text = F.relu(self.proj_text(text_stats))    # [batch_size, hidden_dim]
+
+        # Объединение узлов (аудио и текст попеременно)
+        nodes = torch.stack([x_audio, x_text], dim=1)  # [batch_size, 2, hidden_dim]
+        nodes = nodes.view(-1, nodes.size(-1))        # [batch_size*2, hidden_dim]
+
+        # Построение графа (полный граф для каждого элемента батча)
+        edge_index = self.build_complete_graph(2)  # Граф для одной пары аудио-текст
+        edge_index = edge_index.to(audio_stats.device)
+
+        # Применение GAT
+        x = F.relu(self.gat1(nodes, edge_index))
+        x = self.gat2(x, edge_index)
+
+        # Разделяем обратно аудио и текст
+        x = x.view(batch_size, 2, -1)  # [batch_size, 2, hidden_dim]
+
+        if self.out_mean:
+            # Усреднение по модальностям
+            fused = torch.mean(x, dim=1)   # [batch_size, hidden_dim]
+
+            return self.fc(fused)
+        else:
+            return x
+
+class GraphFusionLayerAtt(nn.Module):
+    def __init__(self, hidden_dim, heads=2):
+        super().__init__()
+        # Проекционные слои для признаков
+        self.proj_audio = nn.Linear(hidden_dim, hidden_dim)
+        self.proj_text = nn.Linear(hidden_dim, hidden_dim)
+
+        # Графовые слои
+        self.gat1 = GATConv(hidden_dim, hidden_dim, heads=heads)
+        self.gat2 = GATConv(hidden_dim*heads, hidden_dim)
+
+        self.attention_fusion = nn.Linear(hidden_dim, 1)
+
+        # Финальная проекция
+        self.fc = nn.Linear(hidden_dim, hidden_dim)
+
+    def build_complete_graph(self, num_nodes):
+        # Создаем полный граф (каждый узел соединен со всеми)
+        edge_index = []
+        for i in range(num_nodes):
+            for j in range(num_nodes):
+                if i != j:
+                    edge_index.append([i, j])
+        return torch.tensor(edge_index).t().contiguous()
+
+    def forward(self, audio_stats, text_stats):
+        """
+        audio_stats: [batch_size, hidden_dim]
+        text_stats: [batch_size, hidden_dim]
+        """
+        batch_size = audio_stats.size(0)
+
+        # Проекция признаков
+        x_audio = F.relu(self.proj_audio(audio_stats))  # [batch_size, hidden_dim]
+        x_text = F.relu(self.proj_text(text_stats))    # [batch_size, hidden_dim]
+
+        # Объединение узлов (аудио и текст попеременно)
+        nodes = torch.stack([x_audio, x_text], dim=1)  # [batch_size, 2, hidden_dim]
+        nodes = nodes.view(-1, nodes.size(-1))        # [batch_size*2, hidden_dim]
+
+        # Построение графа (полный граф для каждого элемента батча)
+        edge_index = self.build_complete_graph(2)  # Граф для одной пары аудио-текст
+        edge_index = edge_index.to(audio_stats.device)
+
+        # Применение GAT
+        x = F.relu(self.gat1(nodes, edge_index))
+        x = self.gat2(x, edge_index)
+
+        # Разделяем обратно аудио и текст
+        x = x.view(batch_size, 2, -1)  # [batch_size, 2, hidden_dim]
+
+        # Усреднение по модальностям
+        # fused = torch.mean(x, dim=1)   # [batch_size, hidden_dim]
+
+        weights = F.softmax(self.attention_fusion(x), dim=1)
+        fused = torch.sum(weights * x, dim=1)  # [batch_size, hidden_dim]
+
+        return self.fc(fused)
+
+# Full code see https://github.com/leson502/CORECT_EMNLP2023/tree/master/corect/model
+
+class GNN(nn.Module):
+    def __init__(self, g_dim, h1_dim, h2_dim, num_relations, num_modals, gcn_conv, use_graph_transformer, graph_transformer_nheads):
+        super(GNN, self).__init__()
+        self.gcn_conv = gcn_conv
+        self.use_graph_transformer=use_graph_transformer
+
+        self.num_modals = num_modals
+
+        if self.gcn_conv == "rgcn":
+            print("GNN --> Use RGCN")
+            self.conv1 = RGCNConv(g_dim, h1_dim, num_relations)
+
+        if self.use_graph_transformer:
+            print("GNN --> Use Graph Transformer")
+
+            in_dim = h1_dim
+
+            self.conv2 = TransformerConv(in_dim, h2_dim, heads=graph_transformer_nheads, concat=True)
+            self.bn = nn.BatchNorm1d(h2_dim * graph_transformer_nheads)
+
+
+    def forward(self, node_features, node_type, edge_index, edge_type):
+        print(node_features.shape, edge_index.shape, edge_type.shape)
+
+        if self.gcn_conv == "rgcn":
+            x = self.conv1(node_features, edge_index, edge_type)
+
+        if self.use_graph_transformer:
+            x = nn.functional.leaky_relu(self.bn(self.conv2(x, edge_index)))
+
+        return x
+
+class GraphModel(nn.Module):
+    def __init__(self, g_dim, h1_dim, h2_dim, device, modalities, wp, wf, edge_type, gcn_conv, use_graph_transformer, graph_transformer_nheads):
+        super(GraphModel, self).__init__()
+
+        self.n_modals = len(modalities)
+        self.wp = wp
+        self.wf = wf
+        self.device = device
+        self.gcn_conv=gcn_conv
+        self.use_graph_transformer=use_graph_transformer
+
+        print(f"GraphModel --> Edge type: {edge_type}")
+        print(f"GraphModel --> Window past: {wp}")
+        print(f"GraphModel --> Window future: {wf}")
+        edge_temp = "temp" in edge_type
+        edge_multi = "multi" in edge_type
+
+        edge_type_to_idx = {}
+
+        if edge_temp:
+            temporal = [-1, 1, 0]
+            for j in temporal:
+                for k in range(self.n_modals):
+                    edge_type_to_idx[str(j) + str(k) + str(k)] = len(edge_type_to_idx)
+        else:
+            for j in range(self.n_modals):
+                edge_type_to_idx['0' + str(j) + str(j)] = len(edge_type_to_idx)
+
+        if edge_multi:
+            for j in range(self.n_modals):
+                for k in range(self.n_modals):
+                    if (j != k):
+                        edge_type_to_idx['0' + str(j) + str(k)] = len(edge_type_to_idx)
+
+        self.edge_type_to_idx = edge_type_to_idx
+        self.num_relations = len(edge_type_to_idx)
+        self.edge_multi = edge_multi
+        self.edge_temp = edge_temp
+
+        self.gnn = GNN(g_dim, h1_dim, h2_dim, self.num_relations, self.n_modals, self.gcn_conv, self.use_graph_transformer, graph_transformer_nheads)
+
+
+    def forward(self, x, lengths):
+        # print(f"x shape: {x.shape}, lengths: {lengths}, lengths.shape: {lengths.shape}")
+
+        node_features = feature_packing(x, lengths)
+
+        node_type, edge_index, edge_type, edge_index_lengths = \
+            self.batch_graphify(lengths)
+
+        out_gnn = self.gnn(node_features, node_type, edge_index, edge_type)
+        out_gnn = multi_concat(out_gnn, lengths, self.n_modals)
+
+        return out_gnn
+
+    def batch_graphify(self, lengths):
+
+        node_type, edge_index, edge_type, edge_index_lengths = [], [], [], []
+        edge_type_lengths = [0] * len(self.edge_type_to_idx)
+
+        lengths = lengths.tolist()
+
+        sum_length = 0
+        total_length = sum(lengths)
+        batch_size = len(lengths)
+
+        for k in range(self.n_modals):
+            for j in range(batch_size):
+                cur_len = lengths[j]
+                node_type.extend([k] * cur_len)
+
+        for j in range(batch_size):
+            cur_len = lengths[j]
+
+            perms = self.edge_perms(cur_len, total_length)
+            edge_index_lengths.append(len(perms))
+
+            for item in perms:
+                vertices = item[0]
+                neighbor = item[1]
+                edge_index.append(torch.tensor([vertices + sum_length, neighbor + sum_length]))
+
+                if vertices % total_length > neighbor % total_length:
+                    temporal_type = 1
+                elif vertices % total_length < neighbor % total_length:
+                    temporal_type = -1
+                else:
+                    temporal_type = 0
+                edge_type.append(self.edge_type_to_idx[str(temporal_type)
+                                                + str(node_type[vertices + sum_length])
+                                                + str(node_type[neighbor + sum_length])])
+
+            sum_length += cur_len
+
+        node_type = torch.tensor(node_type).long().to(self.device)
+        edge_index = torch.stack(edge_index).t().contiguous().to(self.device)  # [2, E]
+        edge_type = torch.tensor(edge_type).long().to(self.device)  # [E]
+        edge_index_lengths = torch.tensor(edge_index_lengths).long().to(self.device)  # [B]
+
+        return node_type, edge_index, edge_type, edge_index_lengths
+
+    def edge_perms(self, length, total_lengths):
+
+        all_perms = set()
+        array = np.arange(length)
+        for j in range(length):
+            if self.wp == -1 and self.wf == -1:
+                eff_array = array
+            elif self.wp == -1:  # use all past context
+                eff_array = array[: min(length, j + self.wf)]
+            elif self.wf == -1:  # use all future context
+                eff_array = array[max(0, j - self.wp) :]
+            else:
+                eff_array = array[
+                    max(0, j - self.wp) : min(length, j + self.wf)
+                ]
+            perms = set()
+
+
+            for k in range(self.n_modals):
+                node_index = j + k * total_lengths
+                if self.edge_temp == True:
+                    for item in eff_array:
+                        perms.add((node_index, item + k * total_lengths))
+                else:
+                    perms.add((node_index, node_index))
+                if self.edge_multi == True:
+                    for l in range(self.n_modals):
+                        if l != k:
+                            perms.add((node_index, j + l * total_lengths))
+
+            all_perms = all_perms.union(perms)
+
+        return list(all_perms)
+
+def feature_packing(multimodal_feature, lengths):
+        batch_size = lengths.size(0)
+        # print(multimodal_feature.shape, batch_size, lengths.shape)
+        node_features = []
+
+        for feature in multimodal_feature:
+            for j in range(batch_size):
+                cur_len = lengths[j].item()
+                # print(f"feature.shape: {feature.shape}, j: {j}, cur_len: {cur_len}")
+                node_features.append(feature[j,:cur_len])
+
+        node_features = torch.cat(node_features, dim=0)
+
+        return node_features
+
+def multi_concat(nodes_feature, lengths, n_modals):
+    sum_length = lengths.sum().item()
+    feature = []
+    for j in range(n_modals):
+        feature.append(nodes_feature[j * sum_length : (j + 1) * sum_length])
+
+    feature = torch.cat(feature, dim=-1)
+
+    return feature
+
+class RMSNorm(nn.Module):
+    def __init__(self, d_model: int, eps: float = 1e-8) -> None:
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim = True) + self.eps) * self.weight
+
+class Mamba(nn.Module):
+    def __init__(self, num_layers, d_input, d_model, d_state=16, d_discr=None, ker_size=4, num_classes=7, pooling=None):
+        super().__init__()
+        mamba_par = {
+            'd_input' : d_input,
+            'd_model' : d_model,
+            'd_state' : d_state,
+            'd_discr' : d_discr,
+            'ker_size': ker_size
+        }
+        self.layers = nn.ModuleList([nn.ModuleList([MambaBlock(**mamba_par), RMSNorm(d_input)]) for _ in range(num_layers)])
+        self.fc_out = nn.Linear(d_input, num_classes)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def forward(self, seq, cache=None):
+        seq = torch.tensor(self.embedding(seq)).to(self.device)
+        for mamba, norm in self.layers:
+            out, cache = mamba(norm(seq), cache)
+            seq = out + seq
+        return self.fc_out(seq.mean(dim = 1))
+
+class MambaBlock(nn.Module):
+    def __init__(self, d_input, d_model, d_state=16, d_discr=None, ker_size=4):
+        super().__init__()
+        d_discr = d_discr if d_discr is not None else d_model // 16
+        self.in_proj  = nn.Linear(d_input, 2 * d_model, bias=False)
+        self.out_proj = nn.Linear(d_model, d_input, bias=False)
+        self.s_B = nn.Linear(d_model, d_state, bias=False)
+        self.s_C = nn.Linear(d_model, d_state, bias=False)
+        self.s_D = nn.Sequential(nn.Linear(d_model, d_discr, bias=False), nn.Linear(d_discr, d_model, bias=False),)
+        self.conv = nn.Conv1d(
+            in_channels=d_model,
+            out_channels=d_model,
+            kernel_size=ker_size,
+            padding=ker_size - 1,
+            groups=d_model,
+            bias=True,
+        )
+        self.A = nn.Parameter(torch.arange(1, d_state + 1, dtype=torch.float).repeat(d_model, 1))
+        self.D = nn.Parameter(torch.ones(d_model, dtype=torch.float))
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def forward(self, seq, cache=None):
+        b, l, d = seq.shape
+        (prev_hid, prev_inp) = cache if cache is not None else (None, None)
+        a, b = self.in_proj(seq).chunk(2, dim=-1)
+        x = rearrange(a, 'b l d -> b d l')
+        x = x if prev_inp is None else torch.cat((prev_inp, x), dim=-1)
+        a = self.conv(x)[..., :l]
+        a = rearrange(a, 'b d l -> b l d')
+        a = silu(a)
+        a, hid = self.ssm(a, prev_hid=prev_hid)
+        b = silu(b)
+        out = a * b
+        out =  self.out_proj(out)
+        if cache:
+            cache = (hid.squeeze(), x[..., 1:])
+        return out, cache
+
+    def ssm(self, seq, prev_hid):
+        A = -self.A
+        D = +self.D
+        B = self.s_B(seq)
+        C = self.s_C(seq)
+        s = softplus(D + self.s_D(seq))
+        A_bar = einsum(torch.exp(A), s, 'd s,   b l d -> b l d s')
+        B_bar = einsum(          B,  s, 'b l s, b l d -> b l d s')
+        X_bar = einsum(B_bar, seq, 'b l d s, b l d -> b l d s')
+        hid = self._hid_states(A_bar, X_bar, prev_hid=prev_hid)
+        out = einsum(hid, C, 'b l d s, b l s -> b l d')
+        out = out + D * seq
+        return out, hid
+
+    def _hid_states(self, A, X, prev_hid=None):
+        b, l, d, s = A.shape
+        A = rearrange(A, 'b l d s -> l b d s')
+        X = rearrange(X, 'b l d s -> l b d s')
+        if prev_hid is not None:
+            return rearrange(A * prev_hid + X, 'l b d s -> b l d s')
+        h = torch.zeros(b, d, s, device=self.device)
+        return torch.stack([h := A_t * h + X_t for A_t, X_t in zip(A, X)], dim=1)

models/models.py

@@ -0,0 +1,1700 @@
+# coding: utf-8
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .help_layers import TransformerEncoderLayer, GAL,GraphFusionLayer, GraphFusionLayerAtt, MambaBlock, RMSNorm
+
+class PredictionsFusion(nn.Module):
+    def __init__(self, num_matrices=2, num_classes=7):
+        super(PredictionsFusion, self).__init__()
+        self.weights = nn.Parameter(torch.rand(num_matrices, num_classes))
+
+    def forward(self, pred):
+        normalized_weights = torch.softmax(self.weights, dim=0)
+        weighted_matrix = sum(mat * normalized_weights[i] for i, mat in enumerate(pred))
+        return weighted_matrix
+
+class MultiModalTransformer_v3(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, hidden_dim=512, hidden_dim_gated=512, num_transformer_heads=2, num_graph_heads=2, seg_len=44, positional_encoding=True, dropout=0, mode='mean', device="cuda",  tr_layer_number=1, out_features=128, num_classes=7):
+        super(MultiModalTransformer_v3, self).__init__()
+
+        self.mode = mode
+
+        self.hidden_dim = hidden_dim
+
+        # Проекционные слои
+        # self.audio_proj = nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity()
+
+        # self.audio_proj = nn.Sequential(
+        #     nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            # nn.LayerNorm(hidden_dim),
+            # nn.Dropout(dropout)
+        # )
+
+        self.audio_proj = nn.Sequential(
+            nn.Conv1d(audio_dim, hidden_dim, 1),
+            nn.GELU(),
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Conv1d(text_dim, hidden_dim, 1),
+            nn.GELU(),
+        )
+        # self.text_proj = nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity()
+
+        # self.text_proj = nn.Sequential(
+        #     nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            # nn.LayerNorm(hidden_dim),
+            # nn.Dropout(dropout)
+        # )
+
+        # Механизмы внимания
+        self.audio_to_text_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+        self.text_to_audio_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+
+        # Классификатор
+        # self.classifier = nn.Sequential(
+        #     nn.Linear(hidden_dim*2, out_features) if self.mode == 'mean' else nn.Linear(hidden_dim*4, out_features),
+        #     nn.ReLU(),
+        #     nn.Linear(out_features, num_classes)
+        # )
+
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim*2, out_features) if self.mode == 'mean' else nn.Linear(hidden_dim*4, out_features),
+            # nn.LayerNorm(out_features),
+            # nn.GELU(),
+            # nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # self._init_weights()
+
+    def forward(self, audio_features, text_features):
+        # Преобразование размерностей
+        audio_features = audio_features.float()
+        text_features = text_features.float()
+
+        # audio_features = self.audio_proj(audio_features)
+        # text_features = self.text_proj(text_features)
+        audio_features = self.audio_proj(audio_features.permute(0,2,1)).permute(0,2,1)
+        text_features = self.text_proj(text_features.permute(0,2,1)).permute(0,2,1)
+
+        # Адаптивная пуллинг до минимальной длины
+        min_seq_len = min(audio_features.size(1), text_features.size(1))
+        audio_features = F.adaptive_avg_pool1d(audio_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+        text_features = F.adaptive_avg_pool1d(text_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+
+        # Трансформерные блоки
+        for i in range(len(self.audio_to_text_attn)):
+            attn_audio = self.audio_to_text_attn[i](text_features, audio_features, audio_features)
+            attn_text = self.text_to_audio_attn[i](audio_features, text_features, text_features)
+            audio_features += attn_audio
+            text_features += attn_text
+
+        # Статистики
+        std_audio, mean_audio = torch.std_mean(attn_audio, dim=1)
+        std_text, mean_text = torch.std_mean(attn_text, dim=1)
+
+        # Классификация
+        if self.mode == 'mean':
+            return self.classifier(torch.cat([mean_audio, mean_audio], dim=1))
+        else:
+            return self.classifier(torch.cat([mean_audio, std_audio, mean_text, std_text], dim=1))
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class MultiModalTransformer_v4(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, hidden_dim=512, hidden_dim_gated=512, num_transformer_heads=2, num_graph_heads=2, seg_len=44, positional_encoding=True, dropout=0, mode='mean', device="cuda",  tr_layer_number=1, out_features=128, num_classes=7):
+        super(MultiModalTransformer_v4, self).__init__()
+
+        self.mode = mode
+
+        self.hidden_dim = hidden_dim
+
+        # Проекционные слои
+        self.audio_proj = nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity()
+        self.text_proj = nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity()
+
+        # Механизмы внимания
+        self.audio_to_text_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+        self.text_to_audio_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+
+        # Графовое слияние вместо GAL
+        if self.mode == 'mean':
+            self.graph_fusion = GraphFusionLayer(hidden_dim, heads=num_graph_heads)
+        else:
+            self.graph_fusion = GraphFusionLayer(hidden_dim*2, heads=num_graph_heads)
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim, out_features) if self.mode == 'mean' else nn.Linear(hidden_dim*2, out_features),
+            nn.ReLU(),
+            nn.Linear(out_features, num_classes)
+        )
+
+    def forward(self, audio_features, text_features):
+        # Преобразование размерностей
+        audio_features = audio_features.float()
+        text_features = text_features.float()
+
+        audio_features = self.audio_proj(audio_features)
+        text_features = self.text_proj(text_features)
+
+        # Адаптивная пуллинг до минимальной длины
+        min_seq_len = min(audio_features.size(1), text_features.size(1))
+        audio_features = F.adaptive_avg_pool1d(audio_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+        text_features = F.adaptive_avg_pool1d(text_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+
+        # Трансформерные блоки
+        for i in range(len(self.audio_to_text_attn)):
+            attn_audio = self.audio_to_text_attn[i](text_features, audio_features, audio_features)
+            attn_text = self.text_to_audio_attn[i](audio_features, text_features, text_features)
+            audio_features += attn_audio
+            text_features += attn_text
+
+        # Статистики
+        std_audio, mean_audio = torch.std_mean(attn_audio, dim=1)
+        std_text, mean_text = torch.std_mean(attn_text, dim=1)
+
+        # Графовое слияние статистик
+        if self.mode == 'mean':
+            h_ta = self.graph_fusion(mean_audio, mean_text)
+        else:
+            h_ta = self.graph_fusion(torch.cat([mean_audio, std_audio], dim=1), torch.cat([mean_text, std_text], dim=1))
+
+        # Классификация
+        return self.classifier(h_ta)
+
+class MultiModalTransformer_v5(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, hidden_dim=512, hidden_dim_gated=512, num_transformer_heads=2, num_graph_heads=2, seg_len=44, tr_layer_number=1, positional_encoding=True, dropout=0, mode='mean', device="cuda",  out_features=128, num_classes=7):
+        super(MultiModalTransformer_v5, self).__init__()
+
+        self.hidden_dim = hidden_dim
+        self.mode = mode
+
+        # Приведение к общей размерности (адаптивные проекции)
+        self.audio_proj = nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity()
+        self.text_proj = nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity()
+
+        # Механизмы внимания
+
+        self.audio_to_text_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+        self.text_to_audio_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_transformer_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+
+        # Гейтед аттеншн
+        if self.mode == 'mean':
+            self.gal = GAL(hidden_dim, hidden_dim, hidden_dim_gated)
+        else:
+            self.gal = GAL(hidden_dim*2, hidden_dim*2, hidden_dim_gated)
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim, out_features),
+            nn.ReLU(),
+            nn.Linear(out_features, num_classes)
+        )
+
+    def forward(self, audio_features, text_features):
+        bs, seq_audio, audio_feat_dim = audio_features.shape
+        bs, seq_text, text_feat_dim = text_features.shape
+
+        text_features = text_features.to(torch.float32)
+        audio_features = audio_features.to(torch.float32)
+
+        # Приведение размерности
+        audio_features = self.audio_proj(audio_features)  # (bs, seq_audio, hidden_dim)
+        text_features = self.text_proj(text_features)    # (bs, seq_text, hidden_dim)
+
+        # Определяем минимальную длину последовательности
+        min_seq_len = min(seq_audio, seq_text)
+
+        # Усреднение до минимальной длины
+        audio_features = F.adaptive_avg_pool2d(audio_features.permute(0, 2, 1), (self.hidden_dim, min_seq_len)).permute(0, 2, 1)
+        text_features = F.adaptive_avg_pool2d(text_features.permute(0, 2, 1), (self.hidden_dim, min_seq_len)).permute(0, 2, 1)
+
+        # Трансформерные блоки
+        for i in range(len(self.audio_to_text_attn)):
+            attn_audio = self.audio_to_text_attn[i](text_features, audio_features, audio_features)
+            attn_text = self.text_to_audio_attn[i](audio_features, text_features, text_features)
+            audio_features += attn_audio
+            text_features += attn_text
+
+        # Статистики
+        std_audio, mean_audio = torch.std_mean(attn_audio, dim=1)
+        std_text, mean_text = torch.std_mean(attn_text, dim=1)
+
+        # # Гейтед аттеншн
+        # h_audio = torch.tanh(self.Wa(torch.cat([min_audio, std_audio], dim=1)))
+        # h_text = torch.tanh(self.Wt(torch.cat([min_text, std_text], dim=1)))
+        # z_ta = torch.sigmoid(self.W_at(torch.cat([min_audio, std_audio, min_text, std_text], dim=1)))
+        # h_ta = z_ta * h_text + (1 - z_ta) * h_audio
+        if self.mode == 'mean':
+            h_ta = self.gal(mean_audio, mean_text)
+        else:
+            h_ta = self.gal(torch.cat([mean_audio, std_audio], dim=1), torch.cat([mean_text, std_text], dim=1))
+
+        # Классификация
+        output = self.classifier(h_ta)
+        return output
+
+class MultiModalTransformer_v7(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, hidden_dim=512, num_heads=2, positional_encoding=True, dropout=0, mode='mean', device="cuda",  tr_layer_number=1, out_features=128, num_classes=7):
+        super(MultiModalTransformer_v7, self).__init__()
+
+        self.mode = mode
+
+        self.hidden_dim = hidden_dim
+
+        # Проекционные слои
+        self.audio_proj = nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity()
+        self.text_proj = nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity()
+
+        # Механизмы внимания
+        self.audio_to_text_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+        self.text_to_audio_attn = nn.ModuleList([TransformerEncoderLayer(input_dim=hidden_dim, num_heads=num_heads, positional_encoding=positional_encoding, dropout=dropout) for i in range(tr_layer_number)
+                ])
+
+        # Графовое слияние вместо GAL
+        if self.mode == 'mean':
+            self.graph_fusion = GraphFusionLayerAtt(hidden_dim, heads=num_heads)
+        else:
+            self.graph_fusion = GraphFusionLayerAtt(hidden_dim*2, heads=num_heads)
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim, out_features) if self.mode == 'mean' else nn.Linear(hidden_dim*2, out_features),
+            nn.ReLU(),
+            nn.Linear(out_features, num_classes)
+        )
+
+    def forward(self, audio_features, text_features):
+        # Преобразование размерностей
+        audio_features = audio_features.float()
+        text_features = text_features.float()
+
+        audio_features = self.audio_proj(audio_features)
+        text_features = self.text_proj(text_features)
+
+        # Адаптивная пуллинг до минимальной длины
+        min_seq_len = min(audio_features.size(1), text_features.size(1))
+        audio_features = F.adaptive_avg_pool1d(audio_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+        text_features = F.adaptive_avg_pool1d(text_features.permute(0,2,1), min_seq_len).permute(0,2,1)
+
+        # Трансформерные блоки
+        for i in range(len(self.audio_to_text_attn)):
+            attn_audio = self.audio_to_text_attn[i](text_features, audio_features, audio_features)
+            attn_text = self.text_to_audio_attn[i](audio_features, text_features, text_features)
+            audio_features += attn_audio
+            text_features += attn_text
+
+        # Статистики
+        std_audio, mean_audio = torch.std_mean(attn_audio, dim=1)
+        std_text, mean_text = torch.std_mean(attn_text, dim=1)
+
+        # Графовое слияние статистик
+        if self.mode == 'mean':
+            h_ta = self.graph_fusion(mean_audio, mean_text)
+        else:
+            h_ta = self.graph_fusion(torch.cat([mean_audio, std_audio], dim=1), torch.cat([mean_audio, std_text], dim=1))
+
+        # Классификация
+        return self.classifier(h_ta)
+
+class BiFormer(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads=2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiFormer, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+        # self.audio_proj = nn.Sequential(
+        #     nn.Conv1d(audio_dim, hidden_dim, 1),
+        #     nn.GELU(),
+        # )
+
+        # self.text_proj = nn.Sequential(
+        #     nn.Conv1d(text_dim, hidden_dim, 1),
+        #     nn.GELU(),
+        # )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.classifier_input_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool = self._pool_features(dummy_audio)
+        text_pool = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool, text_pool], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return torch.cat([mean_temp, mean_feat], dim=1)
+
+    def forward(self, audio_features, text_features):
+        # Проекция признаков
+        # audio = self.audio_proj(audio_features.permute(0,2,1)).permute(0,2,1)
+        # text = self.text_proj(text_features.permute(0,2,1)).permute(0,2,1)
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool = self._pool_features(audio)
+        text_pool = self._pool_features(text)
+
+        # Классификация
+        features = torch.cat([audio_pool, text_pool], dim=1)
+        return self.classifier(features)
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiGraphFormer(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads = 2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiGraphFormer, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.graph_fusion_feat = GraphFusionLayer(self.seg_len, heads=num_graph_heads)
+        self.graph_fusion_temp = GraphFusionLayer(hidden_dim, heads=num_graph_heads)
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.classifier_input_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # Финальная проекция графов
+        self.fc_feat = nn.Sequential(
+            nn.Linear(self.seg_len, self.seg_len),
+            nn.LayerNorm(self.seg_len),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_temp = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool_temp, audio_pool_feat = self._pool_features(dummy_audio)
+        # text_pool_temp, _ = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool_temp, audio_pool_feat], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return mean_temp,  mean_feat
+
+    def forward(self, audio_features, text_features):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool_temp, audio_pool_feat = self._pool_features(audio)
+        text_pool_temp, text_pool_feat = self._pool_features(text)
+
+        # print(audio_pool_temp.shape, audio_pool_feat.shape, text_pool_temp.shape, text_pool_feat.shape)
+
+        graph_feat = self.graph_fusion_feat(audio_pool_feat, text_pool_feat)
+        graph_temp = self.graph_fusion_temp(audio_pool_temp, text_pool_temp)
+
+        # print(graph_feat.shape, graph_temp.shape)
+        # print(torch.mean(graph_feat, dim=1).shape, torch.mean(graph_temp, dim=1).shape)
+
+        # graph_feat = self.fc_feat(graph_feat)
+        # graph_temp = self.fc_temp(graph_temp)
+
+        # Классификация
+        features = torch.cat([graph_feat, graph_temp], dim=1)
+
+        # print(graph_feat.shape, graph_temp.shape, features.shape)
+        return self.classifier(features)
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+
+class BiGatedGraphFormer(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads = 2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiGatedGraphFormer, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.graph_fusion_feat = GraphFusionLayer(self.seg_len, heads=num_graph_heads, out_mean=False)
+        self.graph_fusion_temp = GraphFusionLayer(hidden_dim, heads=num_graph_heads, out_mean=False)
+
+        self.gated_feat = GAL(self.seg_len, self.seg_len, hidden_dim_gated, dropout_rate=dropout)
+        self.gated_temp = GAL(hidden_dim, hidden_dim, hidden_dim_gated, dropout_rate=dropout)
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim_gated*2, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # Финальная проекция граф��в
+        self.fc_graph_feat = nn.Sequential(
+            nn.Linear(self.seg_len, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_graph_temp = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        # Финальная проекция gated
+        self.fc_gated_feat = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_gated_temp = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool_temp, audio_pool_feat = self._pool_features(dummy_audio)
+        # text_pool_temp, _ = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool_temp, audio_pool_feat], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return mean_temp,  mean_feat
+
+    def forward(self, audio_features, text_features):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool_temp, audio_pool_feat = self._pool_features(audio)
+        text_pool_temp, text_pool_feat = self._pool_features(text)
+
+        # print(audio_pool_temp.shape, audio_pool_feat.shape, text_pool_temp.shape, text_pool_feat.shape)
+
+        graph_feat = self.graph_fusion_feat(audio_pool_feat, text_pool_feat)
+        graph_temp = self.graph_fusion_temp(audio_pool_temp, text_pool_temp)
+
+        gated_feat = self.gated_feat(graph_feat[:, 0, :], graph_feat[:, 1, :])
+        gated_temp = self.gated_temp(graph_temp[:, 0, :], graph_temp[:, 1, :])
+
+        fused_feat = self.fc_graph_feat(torch.mean(graph_feat, dim=1)) + self.fc_gated_feat(gated_feat)
+        fused_temp = self.fc_graph_temp(torch.mean(graph_temp, dim=1)) + self.fc_gated_feat(gated_temp)
+
+        # print(graph_feat.shape, graph_temp.shape)
+        # print(torch.mean(graph_feat, dim=1).shape, torch.mean(graph_temp, dim=1).shape)
+
+        # graph_feat = self.fc_feat(graph_feat)
+        # graph_temp = self.fc_temp(graph_temp)
+
+        # Классификация
+        features = torch.cat([fused_feat, fused_temp], dim=1)
+
+        # print(graph_feat.shape, graph_temp.shape, features.shape)
+        return self.classifier(features)
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+
+class BiFormerWithProb(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads=2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiFormerWithProb, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+        # self.audio_proj = nn.Sequential(
+        #     nn.Conv1d(audio_dim, hidden_dim, 1),
+        #     nn.GELU(),
+        # )
+
+        # self.text_proj = nn.Sequential(
+        #     nn.Conv1d(text_dim, hidden_dim, 1),
+        #     nn.GELU(),
+        # )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.classifier_input_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        self.pred_fusion = PredictionsFusion(num_matrices=3, num_classes=num_classes)
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool = self._pool_features(dummy_audio)
+        text_pool = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool, text_pool], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return torch.cat([mean_temp, mean_feat], dim=1)
+
+    def forward(self, audio_features, text_features, audio_pred, text_pred):
+        # Проекция признаков
+        # audio = self.audio_proj(audio_features.permute(0,2,1)).permute(0,2,1)
+        # text = self.text_proj(text_features.permute(0,2,1)).permute(0,2,1)
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool = self._pool_features(audio)
+        text_pool = self._pool_features(text)
+
+        # Классификация
+        features = torch.cat([audio_pool, text_pool], dim=1)
+
+        out = self.classifier(features)
+
+        w_out = self.pred_fusion([audio_pred, text_pred, out])
+        return w_out
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiGraphFormerWithProb(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads = 2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiGraphFormerWithProb, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.graph_fusion_feat = GraphFusionLayer(self.seg_len, heads=num_graph_heads)
+        self.graph_fusion_temp = GraphFusionLayer(hidden_dim, heads=num_graph_heads)
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.classifier_input_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # Финальная проекция графов
+        self.fc_feat = nn.Sequential(
+            nn.Linear(self.seg_len, self.seg_len),
+            nn.LayerNorm(self.seg_len),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_temp = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.pred_fusion = PredictionsFusion(num_matrices=3, num_classes=num_classes)
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool_temp, audio_pool_feat = self._pool_features(dummy_audio)
+        # text_pool_temp, _ = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool_temp, audio_pool_feat], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return mean_temp,  mean_feat
+
+    def forward(self, audio_features, text_features, audio_pred, text_pred):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool_temp, audio_pool_feat = self._pool_features(audio)
+        text_pool_temp, text_pool_feat = self._pool_features(text)
+
+        # print(audio_pool_temp.shape, audio_pool_feat.shape, text_pool_temp.shape, text_pool_feat.shape)
+
+        graph_feat = self.graph_fusion_feat(audio_pool_feat, text_pool_feat)
+        graph_temp = self.graph_fusion_temp(audio_pool_temp, text_pool_temp)
+
+        # print(graph_feat.shape, graph_temp.shape)
+        # print(torch.mean(graph_feat, dim=1).shape, torch.mean(graph_temp, dim=1).shape)
+
+        # graph_feat = self.fc_feat(graph_feat)
+        # graph_temp = self.fc_temp(graph_temp)
+
+        # Классификация
+        features = torch.cat([graph_feat, graph_temp], dim=1)
+
+        # print(graph_feat.shape, graph_temp.shape, features.shape)
+        out = self.classifier(features)
+
+        w_out = self.pred_fusion([audio_pred, text_pred, out])
+        return w_out
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiGatedGraphFormerWithProb(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads = 2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiGatedGraphFormerWithProb, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.graph_fusion_feat = GraphFusionLayer(self.seg_len, heads=num_graph_heads, out_mean=False)
+        self.graph_fusion_temp = GraphFusionLayer(hidden_dim, heads=num_graph_heads, out_mean=False)
+
+        self.gated_feat = GAL(self.seg_len, self.seg_len, hidden_dim_gated, dropout_rate=dropout)
+        self.gated_temp = GAL(hidden_dim, hidden_dim, hidden_dim_gated, dropout_rate=dropout)
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim_gated*2, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # Финальная проекция графов
+        self.fc_graph_feat = nn.Sequential(
+            nn.Linear(self.seg_len, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_graph_temp = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        # Финальная проекция gated
+        self.fc_gated_feat = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_gated_temp = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.pred_fusion = PredictionsFusion(num_matrices=3, num_classes=num_classes)
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool_temp, audio_pool_feat = self._pool_features(dummy_audio)
+        # text_pool_temp, _ = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool_temp, audio_pool_feat], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return mean_temp,  mean_feat
+
+    def forward(self, audio_features, text_features, audio_pred, text_pred):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool_temp, audio_pool_feat = self._pool_features(audio)
+        text_pool_temp, text_pool_feat = self._pool_features(text)
+
+        # print(audio_pool_temp.shape, audio_pool_feat.shape, text_pool_temp.shape, text_pool_feat.shape)
+
+        graph_feat = self.graph_fusion_feat(audio_pool_feat, text_pool_feat)
+        graph_temp = self.graph_fusion_temp(audio_pool_temp, text_pool_temp)
+
+        gated_feat = self.gated_feat(graph_feat[:, 0, :], graph_feat[:, 1, :])
+        gated_temp = self.gated_temp(graph_temp[:, 0, :], graph_temp[:, 1, :])
+
+        fused_feat = self.fc_graph_feat(torch.mean(graph_feat, dim=1)) + self.fc_gated_feat(gated_feat)
+        fused_temp = self.fc_graph_temp(torch.mean(graph_temp, dim=1)) + self.fc_gated_feat(gated_temp)
+
+        # print(graph_feat.shape, graph_temp.shape)
+        # print(torch.mean(graph_feat, dim=1).shape, torch.mean(graph_temp, dim=1).shape)
+
+        # graph_feat = self.fc_feat(graph_feat)
+        # graph_temp = self.fc_temp(graph_temp)
+
+        # Классификация
+        features = torch.cat([fused_feat, fused_temp], dim=1)
+
+        # print(graph_feat.shape, graph_temp.shape, features.shape)
+        out = self.classifier(features)
+
+        w_out = self.pred_fusion([audio_pred, text_pred, out])
+        return w_out
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiGatedFormer(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, hidden_dim_gated=128,
+                num_transformer_heads=2, num_graph_heads = 2, positional_encoding=True, dropout=0.1, mode='mean',
+                device="cuda", tr_layer_number=1, out_features=128, num_classes=7):
+        super(BiGatedFormer, self).__init__()
+
+        self.mode = mode
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.tr_layer_number = tr_layer_number
+
+        # Проекционные слои с нормализацией
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim) if audio_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim) if text_dim != hidden_dim else nn.Identity(),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Трансформерные слои (сохраняем вашу реализацию)
+        self.audio_to_text_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        self.text_to_audio_attn = nn.ModuleList([
+            TransformerEncoderLayer(
+                input_dim=hidden_dim,
+                num_heads=num_transformer_heads,
+                dropout=dropout,
+                positional_encoding=positional_encoding
+            ) for _ in range(tr_layer_number)
+        ])
+
+        # self.graph_fusion_feat = GraphFusionLayer(self.seg_len, heads=num_graph_heads, out_mean=False)
+        # self.graph_fusion_temp = GraphFusionLayer(hidden_dim, heads=num_graph_heads, out_mean=False)
+
+        self.gated_feat = GAL(self.seg_len, self.seg_len, hidden_dim_gated, dropout_rate=dropout)
+        self.gated_temp = GAL(hidden_dim, hidden_dim, hidden_dim_gated, dropout_rate=dropout)
+
+        # Автоматический расчёт размерности для классификатора
+        self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim_gated*2, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        # Финальная проекция графов
+        # self.fc_graph_feat = nn.Sequential(
+        #     nn.Linear(self.seg_len, hidden_dim_gated),
+        #     nn.LayerNorm(hidden_dim_gated),
+        #     nn.Dropout(dropout)
+        # )
+
+        # self.fc_graph_temp = nn.Sequential(
+        #     nn.Linear(hidden_dim, hidden_dim_gated),
+        #     nn.LayerNorm(hidden_dim_gated),
+        #     nn.Dropout(dropout)
+        # )
+
+        # Финальная проекция gated
+        self.fc_gated_feat = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self.fc_gated_temp = nn.Sequential(
+            nn.Linear(hidden_dim_gated, hidden_dim_gated),
+            nn.LayerNorm(hidden_dim_gated),
+            nn.Dropout(dropout)
+        )
+
+        self._init_weights()
+
+    def _calculate_classifier_input_dim(self):
+        """Вычисляет размер входных признаков для классификатора"""
+        # Тестовый проход через пулинг с dummy-данными
+        dummy_audio = torch.randn(1, self.seg_len, self.hidden_dim)
+        dummy_text = torch.randn(1, self.seg_len, self.hidden_dim)
+
+        audio_pool_temp, audio_pool_feat = self._pool_features(dummy_audio)
+        # text_pool_temp, _ = self._pool_features(dummy_text)
+
+        combined = torch.cat([audio_pool_temp, audio_pool_feat], dim=1)
+        self.classifier_input_dim = combined.size(1)
+
+    def _pool_features(self, x):
+        # Статистики по временной оси (seq_len)
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+
+        # Статистики по feature оси  (hidden_dim)
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+
+        return mean_temp,  mean_feat
+
+    def forward(self, audio_features, text_features):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())
+        text = self.text_proj(text_features.float())
+
+        # Адаптивный пулинг
+        min_len = min(audio.size(1), text.size(1))
+        audio = self.adaptive_temporal_pool(audio, min_len)
+        text = self.adaptive_temporal_pool(text, min_len)
+
+        # Кросс-модальное взаимодействие
+        for i in range(self.tr_layer_number):
+            attn_audio = self.audio_to_text_attn[i](text, audio, audio)
+            attn_text = self.text_to_audio_attn[i](audio, text, text)
+
+            audio = audio + attn_audio
+            text = text + attn_text
+
+        # Агрегация признаков
+        audio_pool_temp, audio_pool_feat = self._pool_features(audio)
+        text_pool_temp, text_pool_feat = self._pool_features(text)
+
+        # print(audio_pool_temp.shape, audio_pool_feat.shape, text_pool_temp.shape, text_pool_feat.shape)
+
+        # graph_feat = self.graph_fusion_feat(audio_pool_feat, text_pool_feat)
+        # graph_temp = self.graph_fusion_temp(audio_pool_temp, text_pool_temp)
+
+        gated_feat = self.gated_feat(audio_pool_feat, text_pool_feat)
+        gated_temp = self.gated_temp(audio_pool_temp, text_pool_temp)
+
+        # fused_feat = self.fc_graph_feat(torch.mean(graph_feat, dim=1)) + self.fc_gated_feat(gated_feat)
+        # fused_temp = self.fc_graph_temp(torch.mean(graph_temp, dim=1)) + self.fc_gated_feat(gated_temp)
+
+        # print(graph_feat.shape, graph_temp.shape)
+        # print(torch.mean(graph_feat, dim=1).shape, torch.mean(graph_temp, dim=1).shape)
+
+        # graph_feat = self.fc_feat(graph_feat)
+        # graph_temp = self.fc_temp(graph_temp)
+
+        # Классификация
+        features = torch.cat([gated_feat, gated_temp], dim=1)
+
+        # print(graph_feat.shape, graph_temp.shape, features.shape)
+        return self.classifier(features)
+
+    def adaptive_temporal_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiMamba(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, mamba_d_state=16,
+                d_discr=None, mamba_ker_size=4, mamba_layer_number=2, dropout=0.1, mode='', positional_encoding=False,
+                out_features=128, num_classes=7, device="cuda"):
+        super(BiMamba, self).__init__()
+
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.num_mamba_layers = mamba_layer_number
+        self.device = device
+
+        # Проекционные слои для каждой модальности
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Слой для объединения модальностей
+        self.fusion_proj = nn.Sequential(
+            nn.Linear(2 * hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Mamba блоки для обработки объединенных признаков
+        mamba_params = {
+            'd_input': hidden_dim,
+            'd_model': hidden_dim,
+            'd_state': mamba_d_state,
+            'd_discr': d_discr,
+            'ker_size': mamba_ker_size
+        }
+
+        self.mamba_blocks = nn.ModuleList([
+            nn.Sequential(
+                MambaBlock(**mamba_params),
+                RMSNorm(hidden_dim)
+            )
+            for _ in range(self.num_mamba_layers)
+        ])
+
+        # Автоматический расчет размерности классификатора
+        # self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.seg_len + self.hidden_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        self._init_weights()
+
+    # def _calculate_classifier_input_dim(self):
+    #     """Вычисляет размер входных признаков для классификатора"""
+    #     dummy = torch.randn(1, self.seg_len, self.hidden_dim)
+    #     pooled = self._pool_features(dummy)
+    #     self.classifier_input_dim = pooled.size(1)
+
+    def _pool_features(self, x):
+        """Объединение временных и feature статистик"""
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+        full_feature = torch.cat([mean_temp, mean_feat], dim=1)
+        if full_feature.shape[-1] == self.seg_len+self.hidden_dim:
+            return torch.cat([mean_temp, mean_feat], dim=1)
+        else:
+            pad_size = self.seg_len+self.hidden_dim - full_feature.shape[-1]
+            return F.pad(full_feature, (0, pad_size), mode="constant", value=0)
+
+    def forward(self, audio_features, text_features):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())  # [B, T, D]
+        text = self.text_proj(text_features.float())     # [B, T, D]
+
+        # Адаптивный пулинг к минимальной длине
+        min_len = min(audio.size(1), text.size(1))
+        audio = self._adaptive_pool(audio, min_len)
+        text = self._adaptive_pool(text, min_len)
+
+        # Объединение модальностей
+        fused = torch.cat([audio, text], dim=-1)  # [B, T, 2*D]
+        fused = self.fusion_proj(fused)           # [B, T, D]
+
+        # Обработка объединенных признаков через Mamba
+        for mamba_block in self.mamba_blocks:
+            out, _ = mamba_block[0](fused, None)
+            out = mamba_block[1](out)
+            fused = fused + out  # Residual connection
+
+        # Агрегация признаков и классификация
+        pooled = self._pool_features(fused)
+        return self.classifier(pooled)
+
+    def _adaptive_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+class BiMambaWithProb(nn.Module):
+    def __init__(self, audio_dim=1024, text_dim=1024, seg_len=44, hidden_dim=512, mamba_d_state=16,
+                d_discr=None, mamba_ker_size=4, mamba_layer_number=2, dropout=0.1, mode='',positional_encoding=False,
+                out_features=128, num_classes=7, device="cuda"):
+        super(BiMambaWithProb, self).__init__()
+
+        self.hidden_dim = hidden_dim
+        self.seg_len = seg_len
+        self.num_mamba_layers = mamba_layer_number
+        self.device = device
+
+        # Проекционные слои для каждой модальности
+        self.audio_proj = nn.Sequential(
+            nn.Linear(audio_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Слой для объединения модальностей
+        self.fusion_proj = nn.Sequential(
+            nn.Linear(2 * hidden_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.Dropout(dropout)
+        )
+
+        # Mamba блоки для обработки объединенных признаков
+        mamba_params = {
+            'd_input': hidden_dim,
+            'd_model': hidden_dim,
+            'd_state': mamba_d_state,
+            'd_discr': d_discr,
+            'ker_size': mamba_ker_size
+        }
+
+        self.mamba_blocks = nn.ModuleList([
+            nn.Sequential(
+                MambaBlock(**mamba_params),
+                RMSNorm(hidden_dim)
+            )
+            for _ in range(self.num_mamba_layers)
+        ])
+
+        # Автоматический расчет размерности классификатора
+        # self._calculate_classifier_input_dim()
+
+        # Классификатор
+        self.classifier = nn.Sequential(
+            nn.Linear(self.seg_len + self.hidden_dim, out_features),
+            nn.LayerNorm(out_features),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(out_features, num_classes)
+        )
+
+        self.pred_fusion = PredictionsFusion(num_matrices=3, num_classes=num_classes)
+
+        self._init_weights()
+
+    # def _calculate_classifier_input_dim(self):
+    #     """Вычисляет размер входных признаков для классификатора"""
+    #     dummy = torch.randn(1, self.seg_len, self.hidden_dim)
+    #     pooled = self._pool_features(dummy)
+    #     self.classifier_input_dim = pooled.size(1)
+
+    def _pool_features(self, x):
+        """Объединение временных и feature статистик"""
+        mean_temp = x.mean(dim=1)  # [batch, hidden_dim]
+        mean_feat = x.mean(dim=-1)  # [batch, seq_len]
+        full_feature = torch.cat([mean_temp, mean_feat], dim=1)
+        if full_feature.shape[-1] == self.seg_len+self.hidden_dim:
+            return torch.cat([mean_temp, mean_feat], dim=1)
+        else:
+            pad_size = self.seg_len+self.hidden_dim - full_feature.shape[-1]
+            return F.pad(full_feature, (0, pad_size), mode="constant", value=0)
+
+    def forward(self, audio_features, text_features, audio_pred, text_pred):
+        # Проекция признаков
+        audio = self.audio_proj(audio_features.float())  # [B, T, D]
+        text = self.text_proj(text_features.float())     # [B, T, D]
+
+        # Адаптивный пулинг к минимальной длине
+        min_len = min(audio.size(1), text.size(1))
+        audio = self._adaptive_pool(audio, min_len)
+        text = self._adaptive_pool(text, min_len)
+
+        # Объединение модальностей
+        fused = torch.cat([audio, text], dim=-1)  # [B, T, 2*D]
+        fused = self.fusion_proj(fused)           # [B, T, D]
+
+        # Обработка объединенных признаков через Mamba
+        for mamba_block in self.mamba_blocks:
+            out, _ = mamba_block[0](fused, None)
+            out = mamba_block[1](out)
+            fused = fused + out  # Residual connection
+
+        # Агрегация признаков и классификация
+        pooled = self._pool_features(fused)
+        out = self.classifier(pooled)
+
+        w_out = self.pred_fusion([audio_pred, text_pred, out])
+        return w_out
+
+    def _adaptive_pool(self, x, target_len):
+        """Адаптивное изменение временной длины"""
+        if x.size(1) == target_len:
+            return x
+        return F.interpolate(
+            x.permute(0, 2, 1),
+            size=target_len,
+            mode='linear',
+            align_corners=False
+        ).permute(0, 2, 1)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)

run_generation.py

@@ -0,0 +1,32 @@
+import sys
+import os
+from generate_synthetic_dataset import generate_from_emotion_csv
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("❌ Использование: python run_generation.py path/to/file.csv [num_processes] [device]")
+        sys.exit(1)
+
+    csv_path = sys.argv[1]
+    num_processes = int(sys.argv[2]) if len(sys.argv) > 2 else int(os.environ.get("NUM_DIA_PROCESSES", 1))
+    device = sys.argv[3] if len(sys.argv) > 3 else "cuda"
+
+    filename = os.path.basename(csv_path)
+    try:
+        emotion = filename.split("_")[2]
+    except IndexError:
+        emotion = "unknown"
+
+    print(f"🧪 CSV: {csv_path}")
+    print(f"💻 Устройство: {device}")
+    print(f"🔧 Процессов: {num_processes}")
+    print(f"🎭 Эмоция: {emotion}")
+
+    generate_from_emotion_csv(
+        csv_path=csv_path,
+        emotion=emotion,
+        output_dir="tts_synthetic_final",
+        device=device,
+        max_samples=None,
+        num_processes=num_processes
+    )

search_params.toml

@@ -0,0 +1,22 @@
+[grid]
+scheduler_type = ["huggingface_cosine_with_restarts", "huggingface_linear", "cosine", "onecycle"]
+smoothing_probability = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
+# mamba_ker_size = [3, 4]
+# mamba_layer_number = [3, 4, 5]
+# hidden_dim_gated     = [128]
+# num_transformer_heads = [2, 4, 8]
+# tr_layer_number       = [1, 2]
+# out_features         = [128, 256]
+# num_graph_heads      = [2, 4]
+# dropout              = [0.0, 0.1, 0.2]
+# positional_encoding  = [true, false]
+
+[defaults]
+hidden_dim = 128
+# # hidden_dim_gated = 128
+# num_transformer_heads = 2
+# tr_layer_number = 1
+# out_features = 128
+# # num_graph_heads = 2
+# dropout = 0
+# positional_encoding = false

synthetic_utils/dia_tts_wrapper.py

@@ -0,0 +1,77 @@
+import os
+import time
+import logging
+import torch
+import soundfile as sf
+import numpy as np
+from dia.model import Dia
+
+
+class DiaTTSWrapper:
+    def __init__(self, model_name="nari-labs/Dia-1.6B", device="cuda", dtype="float16"):
+        self.device = device
+        self.sr = 44100
+        logging.info(f"[DiaTTS] Загрузка модели {model_name} на {device} (dtype={dtype})")
+        self.model = Dia.from_pretrained(
+            model_name,
+            device=device,
+            compute_dtype=dtype
+        )
+
+    def generate_audio_from_text(self, text: str, paralinguistic: str = "", max_duration: float = None) -> torch.Tensor:
+        try:
+            if paralinguistic:
+                clean = paralinguistic.strip("()").lower()
+                text = f"{text} ({clean})"
+            audio_np = self.model.generate(
+                text,
+                use_torch_compile=False,
+                verbose=False
+            )
+            wf = torch.from_numpy(audio_np).float().unsqueeze(0)
+            if max_duration:
+                max_samples = int(self.sr * max_duration)
+                wf = wf[:, :max_samples]
+            return wf
+        except Exception as e:
+            logging.error(f"[DiaTTS] Ошибка генерации аудио: {e}")
+            return torch.zeros(1, self.sr)
+
+    def generate_and_save_audio(
+        self,
+        text: str,
+        paralinguistic: str = "",
+        out_dir="tts_outputs",
+        filename_prefix="tts",
+        max_duration: float = None,
+        use_timestamp=True,
+        skip_if_exists=True,
+        max_trim_duration: float = None
+    ) -> torch.Tensor:
+        os.makedirs(out_dir, exist_ok=True)
+        if use_timestamp:
+            timestr = time.strftime("%Y%m%d_%H%M%S")
+            filename = f"{filename_prefix}_{timestr}.wav"
+        else:
+            filename = f"{filename_prefix}.wav"
+        out_path = os.path.join(out_dir, filename)
+
+        if skip_if_exists and os.path.exists(out_path):
+            logging.info(f"[DiaTTS] ⏭️ Пропущено — уже существует: {out_path}")
+            return None
+
+        wf = self.generate_audio_from_text(text, paralinguistic, max_duration)
+        np_wf = wf.squeeze().cpu().numpy()
+
+        if max_trim_duration is not None:
+            max_len = int(self.sr * max_trim_duration)
+            if len(np_wf) > max_len:
+                logging.info(f"[DiaTTS] ✂️ Обрезка аудио до {max_trim_duration} сек.")
+                np_wf = np_wf[:max_len]
+
+        sf.write(out_path, np_wf, self.sr)
+        logging.info(f"[DiaTTS] 💾 Сохранено аудио: {out_path}")
+        return wf
+
+    def get_sample_rate(self):
+        return self.sr

synthetic_utils/parler_tts_wrapper.py

@@ -0,0 +1,60 @@
+# parler_tts_wrapper.py
+
+import torch
+import soundfile as sf
+import time
+import os
+import logging
+from parler_tts import ParlerTTSForConditionalGeneration
+from transformers import AutoTokenizer
+
+class ParlerTTS:
+    def __init__(self, model_name="parler-tts/parler-tts-mini-v1", device="cuda"):
+        self.device = device
+        logging.info(f"[ParlerTTS] Загрузка модели {model_name} на {device} ...")
+
+        self.model = ParlerTTSForConditionalGeneration.from_pretrained(model_name).to(device)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.sr = self.model.config.sampling_rate
+
+    def generate_audio_from_text(self, text: str, description: str) -> torch.Tensor:
+        """
+        Генерирует аудио (без сохранения на диск).
+        Возвращает PyTorch-тензор формы (1, num_samples).
+        """
+        input_ids = self.tokenizer(description, return_tensors="pt").input_ids.to(self.device)
+        prompt_input_ids = self.tokenizer(text, return_tensors="pt").input_ids.to(self.device)
+
+        with torch.no_grad():
+            generation = self.model.generate(
+                input_ids=input_ids,
+                prompt_input_ids=prompt_input_ids
+            )
+
+        audio_arr = generation.cpu().numpy().squeeze()  # (samples,)
+        wf = torch.from_numpy(audio_arr).unsqueeze(0)    # -> (1, samples)
+        return wf
+
+    def generate_and_save_audio(self, text: str, description: str, out_dir="tts_outputs", filename_prefix="tts") -> torch.Tensor:
+        """
+        Генерирует аудио И сохраняет результат в WAV-файл (для отладки/проверки).
+        Возвращает PyTorch-тензор (1, num_samples).
+        """
+        os.makedirs(out_dir, exist_ok=True)
+
+        wf = self.generate_audio_from_text(text, description)
+        np_wf = wf.squeeze().cpu().numpy()
+
+        # Формируем имя файла
+        timestr = time.strftime("%Y%m%d_%H%M%S")
+        filename = f"{filename_prefix}_{timestr}.wav"
+        out_path = os.path.join(out_dir, filename)
+
+        # Сохраняем
+        sf.write(out_path, np_wf, self.sr)
+        logging.info(f"[ParlerTTS] Сохранено аудио: {out_path}")
+
+        return wf
+
+    def get_sample_rate(self):
+        return self.sr

synthetic_utils/text_generation.py

@@ -0,0 +1,91 @@
+import logging
+import torch
+import random
+from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
+
+class TextGenerator:
+    def __init__(
+        self,
+        model_name="gpt2",
+        device="cuda",
+        max_new_tokens=50,
+        temperature=1.0,
+        top_p=0.95,
+        seed=None
+    ):
+        self.model_name = model_name
+        self.device = device
+        self.max_new_tokens = max_new_tokens
+        self.temperature = temperature
+        self.top_p = top_p
+        self.seed = seed
+
+        logging.info(f"[TextGenerator] Загрузка модели {model_name} на {device} ...")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
+
+        if seed is not None:
+            set_seed(seed)
+            logging.info(f"[TextGenerator] Сид генерации установлен через transformers.set_seed({seed})")
+        else:
+            logging.info("[TextGenerator] Сид генерации не установлен (seed=None)")
+
+        # --- Примеры для few-shot обучения ---
+        self.fewshot_examples = [
+            ("happy", "We finally made it!", "We finally made it! I’ve never felt so alive and proud of what we accomplished."),
+            ("sad", "He didn't come back.", "He didn't come back. I waited all night, hoping to see him again."),
+            ("anger", "Why would you do that?", "Why would you do that? You had no right to interfere!"),
+            ("fear", "Did you hear that?", "Did you hear that? Something’s moving outside the window..."),
+            ("surprise", "Oh wow, really?", "Oh wow, really? I didn’t see that coming at all!"),
+            ("disgust", "That smell is awful.", "That smell is awful. I feel like I’m going to be sick."),
+            ("neutral", "Let's meet at noon.", "Let's meet at noon. We’ll have plenty of time to talk then.")
+        ]
+
+    def build_prompt(self, emotion: str, partial_text: str) -> str:
+        few_shot = random.sample(self.fewshot_examples, 2)
+        examples_str = ""
+        for emo, text, cont in few_shot:
+            examples_str += (
+                f"Example:\n"
+                f"Emotion: {emo}\n"
+                f"Text: {text}\n"
+                f"Continuation: {cont}\n\n"
+            )
+
+        prompt = (
+            "You are a helpful assistant that generates emotionally-aligned sentence continuations.\n"
+            "You must include the original sentence in the output, and then continue it in a fluent and emotionally appropriate way.\n\n"
+            f"{examples_str}"
+            f"Now try:\n"
+            f"Emotion: {emotion}\n"
+            f"Text: {partial_text}\n"
+            f"Continuation:"
+        )
+        return prompt
+
+    def generate_text(self, emotion: str, partial_text: str = "") -> str:
+        prompt = self.build_prompt(emotion, partial_text)
+        logging.debug(f"[TextGenerator] prompt:\n{prompt}")
+
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+
+        output_ids = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            do_sample=True,
+            top_p=self.top_p,
+            temperature=self.temperature,
+            pad_token_id=self.tokenizer.eos_token_id
+        )
+
+        full_text = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        logging.debug(f"[TextGenerator] decoded:\n{full_text}")
+
+        # Вытаскиваем то, что идёт после последнего "Continuation:"
+        if "Continuation:" in full_text:
+            result = full_text.split("Continuation:")[-1].strip()
+        else:
+            result = full_text.strip()
+
+        result = result.split("\n")[0].strip()
+        return result

test.py

@@ -0,0 +1,28 @@
+# tts_test_run.py
+
+import os
+from utils.config_loader import ConfigLoader
+from synthetic_utils.dia_tts_wrapper import DiaTTSWrapper
+from generate_synthetic_dataset import PARALINGUISTIC_MARKERS
+
+# Загружаем конфиг
+config = ConfigLoader("config.toml")
+
+# Настройка TTS
+tts = DiaTTSWrapper(device=config.whisper_device)
+
+# Пример текста и эмоции
+text = "I'm just testing how this emotional voice sounds."
+emotion = "neutral"  # можно: neutral, happy, sad, anger, fear, surprise, disgust
+marker = PARALINGUISTIC_MARKERS.get(emotion, "")
+
+# Генерация и сохранение
+tts.generate_and_save_audio(
+    text=text,
+    paralinguistic=marker,
+    out_dir="tts_test_outputs",
+    filename_prefix=f"test_{emotion}",
+    max_duration=5.0
+)
+
+print(f"✅ Аудио для эмоции '{emotion}' сохранено.")

training/train_utils.py

@@ -0,0 +1,585 @@
+# coding: utf-8
+# train_utils.py
+
+import torch
+import logging
+import random
+import numpy as np
+import csv
+import pandas as pd
+from tqdm import tqdm
+from typing import Type
+import os
+import datetime
+
+from torch.utils.data import DataLoader, ConcatDataset, WeightedRandomSampler
+from torch.nn.utils.rnn import pad_sequence
+
+from utils.losses import WeightedCrossEntropyLoss
+from utils.measures import uar, war, mf1, wf1
+from models.models import (
+    BiFormer, BiGraphFormer, BiGatedGraphFormer,
+    PredictionsFusion, BiFormerWithProb, BiGatedFormer,
+    BiMamba, BiMambaWithProb,BiGraphFormerWithProb, BiGatedGraphFormerWithProb
+)
+from utils.schedulers import SmartScheduler
+from data_loading.dataset_multimodal import DatasetMultiModalWithPretrainedExtractors
+from sklearn.utils.class_weight import compute_class_weight
+from lion_pytorch import Lion
+
+
+def get_smoothed_labels(audio_paths, original_labels, smooth_labels_df, smooth_mask, emotion_columns,  device):
+    """
+    audio_paths: список путей к аудиофайлам
+    smooth_mask: тензор boolean с индексами для сглаживания
+    Возвращает тензор сглаженных меток только для отмеченных примеров
+    """
+
+    # Получаем индексы для сглаживания
+    smooth_indices = torch.where(smooth_mask)[0]
+
+    # Создаем тензор для результатов (такого же размера как оригинальные метки)
+    smoothed_labels = torch.zeros_like(original_labels)
+
+    # print(smooth_labels_df, audio_paths)
+
+    for idx in smooth_indices:
+        audio_path = audio_paths[idx]
+        # Получаем сглаженную метку из вашего DataFrame или другого источника
+        smoothed_label = smooth_labels_df.loc[
+            smooth_labels_df['video_name'] == audio_path[:-4],
+            emotion_columns
+        ].values[0]
+
+        smoothed_labels[idx] = torch.tensor(smoothed_label, device=device)
+
+    return smoothed_labels
+
+def custom_collate_fn(batch):
+    """Собирает список образцов в единый батч, отбрасывая None (невалидные)."""
+    batch = [x for x in batch if x is not None]
+    # print(batch[0].keys())
+    if not batch:
+        return None
+
+    audios = [b["audio"] for b in batch]
+    # audio_tensor = torch.stack(audios)
+    audio_tensor = pad_sequence(audios, batch_first=True)
+
+    labels = [b["label"] for b in batch]
+    label_tensor = torch.stack(labels)
+
+    texts = [b["text"] for b in batch]
+    text_tensor = torch.stack(texts)
+
+    audio_pred = [b["audio_pred"] for b in batch]
+    audio_pred = torch.stack(audio_pred)
+
+    text_pred = [b["text_pred"] for b in batch]
+    text_pred = torch.stack(text_pred)
+
+    return {
+        "audio_paths": [b["audio_path"] for b in batch], # new
+        "audio": audio_tensor,
+        "label": label_tensor,
+        "text": text_tensor,
+        "audio_pred": audio_pred,
+        "text_pred": text_pred,
+    }
+
+def get_class_weights_from_loader(train_loader, num_classes):
+    """
+    Вычисляет веса классов из train_loader, устойчиво к отсутствующим классам.
+    Если какой-либо класс отсутствует в выборке, ему будет присвоен вес 0.0.
+
+    :param train_loader: DataLoader с one-hot метками
+    :param num_classes: Общее количество классов
+    :return: np.ndarray весов длины num_classes
+    """
+    all_labels = []
+    for batch in train_loader:
+        if batch is None:
+            continue
+        all_labels.extend(batch["label"].argmax(dim=1).tolist())
+
+    if not all_labels:
+        raise ValueError("Нет ни одной метки в train_loader для вычисления весов классов.")
+
+    present_classes = np.unique(all_labels)
+
+    if len(present_classes) < num_classes:
+        missing = set(range(num_classes)) - set(present_classes)
+        logging.info(f"[!] Отсутствуют метки для классов: {sorted(missing)}")
+
+    # Вычисляем веса только по тем классам, что есть
+    weights_partial = compute_class_weight(
+        class_weight="balanced",
+        classes=present_classes,
+        y=all_labels
+    )
+
+    # Собираем полный вектор весов
+    full_weights = np.zeros(num_classes, dtype=np.float32)
+    for cls, w in zip(present_classes, weights_partial):
+        full_weights[cls] = w
+
+    return full_weights
+
+def make_dataset_and_loader(config, split: str, audio_feature_extractor: Type = None, text_feature_extractor: Type = None, whisper_model: Type = None, only_dataset: str = None):
+    """
+    Универсальная функция: объединяет датасеты или возвращает один п��и only_dataset.
+    При объединении train-датасетов — использует WeightedRandomSampler для балансировки.
+    """
+    datasets = []
+
+    if not hasattr(config, "datasets") or not config.datasets:
+        raise ValueError("⛔ В конфиге не указана секция [datasets].")
+
+    for dataset_name, dataset_cfg in config.datasets.items():
+        if only_dataset and dataset_name != only_dataset:
+            continue
+
+        csv_path = dataset_cfg["csv_path"].format(base_dir=dataset_cfg["base_dir"], split=split)
+        wav_dir  = dataset_cfg["wav_dir"].format(base_dir=dataset_cfg["base_dir"], split=split)
+
+        logging.info(f"[{dataset_name.upper()}] Split={split}: CSV={csv_path}, WAV_DIR={wav_dir}")
+
+        dataset = DatasetMultiModalWithPretrainedExtractors(
+            csv_path                = csv_path,
+            wav_dir                 = wav_dir,
+            emotion_columns         = config.emotion_columns,
+            split                   = split,
+            config                  = config,
+            audio_feature_extractor = audio_feature_extractor,
+            text_feature_extractor  = text_feature_extractor,
+            whisper_model           = whisper_model,
+            dataset_name            = dataset_name
+        )
+
+        datasets.append(dataset)
+
+    if not datasets:
+        raise ValueError(f"⚠️ Для split='{split}' не найдено ни одного подходящего датасета.")
+
+    if len(datasets) == 1:
+
+        full_dataset = datasets[0]
+        loader = DataLoader(
+            full_dataset,
+            batch_size=config.batch_size,
+            shuffle=(split == "train"),
+            num_workers=config.num_workers,
+            collate_fn=custom_collate_fn
+        )
+    else:
+        # Несколько датасетов — собираем веса
+        lengths = [len(d) for d in datasets]
+        total = sum(lengths)
+
+        logging.info(f"[!] Объединяем {len(datasets)} датасетов: {lengths} (total={total})")
+
+        weights = []
+        for d_len in lengths:
+            w = 1.0 / d_len
+            weights += [w] * d_len
+            logging.info(f"  ➜ Сэмплы из датасета с {d_len} примерами получают вес {w:.6f}")
+
+        full_dataset = ConcatDataset(datasets)
+
+        if split == "train":
+            sampler = WeightedRandomSampler(weights, num_samples=total, replacement=True)
+            loader = DataLoader(
+                full_dataset,
+                batch_size=config.batch_size,
+                sampler=sampler,
+                num_workers=config.num_workers,
+                collate_fn=custom_collate_fn
+            )
+        else:
+            loader = DataLoader(
+                full_dataset,
+                batch_size=config.batch_size,
+                shuffle=False,
+                num_workers=config.num_workers,
+                collate_fn=custom_collate_fn
+            )
+
+    return full_dataset, loader
+
+def run_eval(model, loader, criterion, model_name,  device="cuda"):
+    """
+    Оценка модели на loader'е. Возвращает (loss, uar, war, mf1, wf1).
+    """
+    model.eval()
+    total_loss = 0.0
+    total_preds = []
+    total_targets = []
+    total = 0
+
+    with torch.no_grad():
+        for batch in tqdm(loader):
+            if batch is None:
+                continue
+
+            audio  = batch["audio"].to(device)
+            labels = batch["label"].to(device)
+            texts  = batch["text"]
+            audio_pred  = batch["audio_pred"].to(device)
+            text_pred = batch["text_pred"].to(device)
+
+            if "fusion" in model_name:
+                logits = model((audio_pred, text_pred))
+            elif "withprob" in model_name:
+                logits = model(audio, texts, audio_pred, text_pred)
+            else:
+                logits = model(audio, texts)
+            target = labels.argmax(dim=1)
+
+            loss = criterion(logits, target)
+            bs = audio.shape[0]
+            total_loss += loss.item() * bs
+            total += bs
+
+            preds = logits.argmax(dim=1)
+            total_preds.extend(preds.cpu().numpy().tolist())
+            total_targets.extend(target.cpu().numpy().tolist())
+
+    avg_loss = total_loss / total
+
+    uar_m = uar(total_targets, total_preds)
+    war_m = war(total_targets, total_preds)
+    mf1_m = mf1(total_targets, total_preds)
+    wf1_m = wf1(total_targets, total_preds)
+
+    return avg_loss, uar_m, war_m, mf1_m, wf1_m
+
+def train_once(config, train_loader, dev_loaders, test_loaders, metrics_csv_path=None):
+    """
+    Логика обучения (train/dev/test).
+    Возвращает лучшую метрику на dev и словарь метрик.
+    """
+
+    logging.info("== Запуск тренировки (train/dev/test) ==")
+
+    checkpoint_dir = None
+    if config.save_best_model:
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        checkpoint_dir = os.path.join("checkpoints", f"{config.model_name}_{timestamp}")
+        os.makedirs(checkpoint_dir, exist_ok=True)
+
+    csv_writer = None
+    csv_file = None
+
+    if config.path_to_df_ls:
+        df_ls = pd.read_csv(config.path_to_df_ls)
+
+    if metrics_csv_path:
+        csv_file = open(metrics_csv_path, mode="w", newline="", encoding="utf-8")
+        csv_writer = csv.writer(csv_file)
+        csv_writer.writerow(["split", "epoch", "dataset", "loss", "uar", "war", "mf1", "wf1", "mean"])
+
+
+    # Seed
+    if config.random_seed > 0:
+        random.seed(config.random_seed)
+        torch.manual_seed(config.random_seed)
+        torch.cuda.manual_seed_all(config.random_seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        os.environ['PYTHONHASHSEED'] = str(config.random_seed)
+        logging.info(f"== Фиксируем random seed: {config.random_seed}")
+    else:
+        logging.info("== Random seed не фиксирован (0).")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # Экстракторы
+    # audio_extractor = AudioEmbeddingExtractor(config)
+    # text_extractor  = TextEmbeddingExtractor(config)
+
+    # Параметры
+    hidden_dim            = config.hidden_dim
+    num_classes           = len(config.emotion_columns)
+    num_transformer_heads = config.num_transformer_heads
+    num_graph_heads       = config.num_graph_heads
+    hidden_dim_gated      = config.hidden_dim_gated
+    mamba_d_state         = config.mamba_d_state
+    mamba_ker_size        = config.mamba_ker_size
+    mamba_layer_number    = config.mamba_layer_number
+    mode                  = config.mode
+    weight_decay          = config.weight_decay
+    momentum              = config.momentum
+    positional_encoding   = config.positional_encoding
+    dropout               = config.dropout
+    out_features          = config.out_features
+    lr                    = config.lr
+    num_epochs            = config.num_epochs
+    tr_layer_number       = config.tr_layer_number
+    max_patience          = config.max_patience
+    scheduler_type        = config.scheduler_type
+
+    dict_models = {
+        'BiFormer': BiFormer, # вход audio, texts
+        'BiGraphFormer': BiGraphFormer, # вход audio, texts
+        'BiGatedGraphFormer': BiGatedGraphFormer, # вход audio, texts
+        "BiGatedFormer": BiGatedFormer, # вход audio, texts
+        "BiMamba": BiMamba, # вход audio, texts
+        "PredictionsFusion": PredictionsFusion, # вход audio_pred, text_pred
+        "BiFormerWithProb": BiFormerWithProb, # вход audio, texts, audio_pred, text_pred
+        "BiMambaWithProb": BiMambaWithProb, # вход audio, texts, audio_pred, text_pred
+        "BiGraphFormerWithProb": BiGraphFormerWithProb, # вход audio, texts, audio_pred, text_pred
+        "BiGatedGraphFormerWithProb": BiGatedGraphFormerWithProb,
+    }
+
+    model_cls = dict_models[config.model_name]
+    model_name = config.model_name.lower()
+
+    if model_name == 'predictionsfusion':
+        model = model_cls().to(device)
+
+    elif 'mamba' in model_name:
+        # Особые параметры для Mamba-семейства
+        model = model_cls(
+            audio_dim             = config.audio_embedding_dim,
+            text_dim              = config.text_embedding_dim,
+            hidden_dim            = hidden_dim,
+            mamba_d_state         = mamba_d_state,
+            mamba_ker_size        = mamba_ker_size,
+            mamba_layer_number    = mamba_layer_number,
+            seg_len               = config.max_tokens,
+            mode                  = mode,
+            dropout               = dropout,
+            positional_encoding   = positional_encoding,
+            out_features          = out_features,
+            device                = device,
+            num_classes           = num_classes
+        ).to(device)
+
+    else:
+        # Обычные модели
+        model = model_cls(
+            audio_dim             = config.audio_embedding_dim,
+            text_dim              = config.text_embedding_dim,
+            hidden_dim            = hidden_dim,
+            hidden_dim_gated      = hidden_dim_gated,
+            num_transformer_heads = num_transformer_heads,
+            num_graph_heads       = num_graph_heads,
+            seg_len               = config.max_tokens,
+            mode                  = mode,
+            dropout               = dropout,
+            positional_encoding   = positional_encoding,
+            out_features          = out_features,
+            tr_layer_number       = tr_layer_number,
+            device                = device,
+            num_classes           = num_classes
+        ).to(device)
+
+    # Оптимизатор и лосс
+    if config.optimizer == "adam":
+        optimizer = torch.optim.Adam(
+            model.parameters(), lr=lr, weight_decay=weight_decay
+        )
+    elif config.optimizer == "adamw":
+        optimizer = torch.optim.AdamW(
+            model.parameters(), lr=lr, weight_decay=weight_decay
+        )
+    elif config.optimizer == "lion":
+        optimizer = Lion(
+            model.parameters(), lr=lr, weight_decay=weight_decay
+        )
+    elif config.optimizer == "sgd":
+        optimizer = torch.optim.SGD(
+            model.parameters(), lr=lr,momentum = momentum
+        )
+    elif config.optimizer == "rmsprop":
+        optimizer = torch.optim.RMSprop(model.parameters(), lr=lr)
+    else:
+        raise ValueError(f"⛔ Неизвестный оптимизатор: {config.optimizer}")
+
+    logging.info(f"Используем оптимизатор: {config.optimizer}, learning rate: {lr}")
+
+    class_weights = get_class_weights_from_loader(train_loader, num_classes)
+    criterion = WeightedCrossEntropyLoss(class_weights)
+
+    logging.info("Class weights: " + ", ".join(f"{name}={weight:.4f}" for name, weight in zip(config.emotion_columns, class_weights)))
+
+    # LR Scheduler
+    steps_per_epoch = sum(1 for batch in train_loader if batch is not None)
+    scheduler = SmartScheduler(
+        scheduler_type=scheduler_type,
+        optimizer=optimizer,
+        config=config,
+        steps_per_epoch=steps_per_epoch
+    )
+
+    # Early stopping по dev
+    best_dev_mean = float("-inf")
+    best_dev_metrics = {}
+    patience_counter = 0
+
+    for epoch in range(num_epochs):
+        logging.info(f"\n=== Эпоха {epoch} ===")
+        model.train()
+
+        total_loss = 0.0
+        total_samples = 0
+        total_preds = []
+        total_targets = []
+
+        for batch in tqdm(train_loader):
+            if batch is None:
+                continue
+
+            audio_paths =  batch["audio_paths"]  # new
+            audio = batch["audio"].to(device)
+
+            # Обработка меток с частичным сглаживанием
+            if config.smoothing_probability == 0:
+                labels = batch["label"].to(device)
+            else:
+                # Получаем оригинальные горячие метки
+                original_labels = batch["label"].to(device)
+
+                # Создаем маску для сглаживания (выбираем случайные примеры)
+                batch_size = original_labels.size(0)
+                smooth_mask = torch.rand(batch_size, device=device) < config.smoothing_probability
+
+                # Получаем сглаженные метки для выбранных примеров
+                smoothed_labels = get_smoothed_labels(audio_paths, original_labels, df_ls, smooth_mask, config.emotion_columns,  device)
+
+                # Комбинируем метки
+                labels = torch.where(
+                    smooth_mask.unsqueeze(1),  # Добавляем размерность для broadcast
+                    smoothed_labels.to(device),
+                    original_labels
+        )
+            # print(labels)
+            texts = batch["text"]
+            audio_pred = batch["audio_pred"].to(device)
+            text_pred = batch["text_pred"].to(device)
+
+            if "fusion" in model_name:
+                logits = model((audio_pred, text_pred))
+            elif "withprob" in model_name:
+                logits = model(audio, texts, audio_pred, text_pred)
+            else:
+                logits = model(audio, texts)
+
+            target = labels.argmax(dim=1)
+            loss   = criterion(logits, target)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+            # Если scheduler - One cycle или с Hugging Face
+            scheduler.step(batch_level=True)
+
+            bs = audio.shape[0]
+            total_loss += loss.item() * bs
+
+            preds = logits.argmax(dim=1)
+            total_preds.extend(preds.cpu().numpy().tolist())
+            total_targets.extend(target.cpu().numpy().tolist())
+            total_samples += bs
+
+        train_loss = total_loss / total_samples
+        uar_m = uar(total_targets, total_preds)
+        war_m = war(total_targets, total_preds)
+        mf1_m = mf1(total_targets, total_preds)
+        wf1_m = wf1(total_targets, total_preds)
+        mean_train = np.mean([uar_m, war_m, mf1_m, wf1_m])
+
+        logging.info(
+            f"[TRAIN] Loss={train_loss:.4f}, UAR={uar_m:.4f}, WAR={war_m:.4f}, "
+            f"MF1={mf1_m:.4f}, WF1={wf1_m:.4f}, MEAN={mean_train:.4f}"
+        )
+
+        # --- DEV ---
+        dev_means = []
+        dev_metrics_by_dataset = []
+
+        for name, loader in dev_loaders:
+            d_loss, d_uar, d_war, d_mf1, d_wf1 = run_eval(
+                model, loader, criterion, model_name, device
+            )
+            d_mean = np.mean([d_uar, d_war, d_mf1, d_wf1])
+            dev_means.append(d_mean)
+
+            if csv_writer:
+                csv_writer.writerow(["dev", epoch, name, d_loss, d_uar, d_war, d_mf1, d_wf1, d_mean])
+
+            logging.info(
+                f"[DEV:{name}] Loss={d_loss:.4f}, UAR={d_uar:.4f}, WAR={d_war:.4f}, "
+                f"MF1={d_mf1:.4f}, WF1={d_wf1:.4f}, MEAN={d_mean:.4f}"
+            )
+
+            dev_metrics_by_dataset.append({
+                "name": name,
+                "loss": d_loss,
+                "uar": d_uar,
+                "war": d_war,
+                "mf1": d_mf1,
+                "wf1": d_wf1,
+                "mean": d_mean,
+            })
+
+        mean_dev = np.mean(dev_means)
+        scheduler.step(mean_dev)
+
+        # --- TEST ---
+        test_metrics_by_dataset = []
+        for name, loader in test_loaders:
+            t_loss, t_uar, t_war, t_mf1, t_wf1 = run_eval(
+                model, loader, criterion, model_name, device
+            )
+            t_mean = np.mean([t_uar, t_war, t_mf1, t_wf1])
+            logging.info(
+                f"[TEST:{name}] Loss={t_loss:.4f}, UAR={t_uar:.4f}, WAR={t_war:.4f}, "
+                f"MF1={t_mf1:.4f}, WF1={t_wf1:.4f}, MEAN={t_mean:.4f}"
+            )
+
+            test_metrics_by_dataset.append({
+                "name": name,
+                "loss": t_loss,
+                "uar": t_uar,
+                "war": t_war,
+                "mf1": t_mf1,
+                "wf1": t_wf1,
+                "mean": t_mean,
+            })
+
+            if csv_writer:
+                csv_writer.writerow(["test", epoch, name, t_loss, t_uar, t_war, t_mf1, t_wf1, t_mean])
+
+
+        if mean_dev > best_dev_mean:
+            best_dev_mean = mean_dev
+            patience_counter = 0
+            best_dev_metrics = {
+                "mean": mean_dev,
+                "by_dataset": dev_metrics_by_dataset
+            }
+            best_test_metrics = {
+                "mean": np.mean([ds["mean"] for ds in test_metrics_by_dataset]),
+                "by_dataset": test_metrics_by_dataset
+            }
+
+            if config.save_best_model:
+                dev_str = f"{mean_dev:.4f}".replace(".", "_")
+                model_path = os.path.join(checkpoint_dir, f"best_model_dev_{dev_str}_epoch_{epoch}.pt")
+                torch.save(model.state_dict(), model_path)
+                logging.info(f"💾 Модель сохранена по лучшему dev (эпоха {epoch}): {model_path}")
+
+        else:
+            patience_counter += 1
+            if patience_counter >= max_patience:
+                logging.info(f"Early stopping: {max_patience} эпох без улучшения.")
+                break
+
+    logging.info("Тренировка завершена. Все split'ы обработаны!")
+
+    if csv_file:
+        csv_file.close()
+
+    return best_dev_mean, best_dev_metrics, best_test_metrics

training/train_utils_old.py

@@ -0,0 +1,379 @@
+# coding: utf-8
+# train_utils.py
+
+import os
+import torch
+import logging
+import random
+import datetime
+import numpy as np
+from tqdm import tqdm
+import csv
+
+from torch.utils.data import DataLoader, ConcatDataset
+from utils.losses import WeightedCrossEntropyLoss
+from utils.measures import uar, war, mf1, wf1
+from models.models import BiFormer, BiGraphFormer, BiGatedGraphFormer
+from data_loading.dataset_multimodal import DatasetMultiModal
+from data_loading.feature_extractor import AudioEmbeddingExtractor, TextEmbeddingExtractor
+from sklearn.utils.class_weight import compute_class_weight
+
+def custom_collate_fn(batch):
+    """Собирает список образцов в единый батч, отбрасывая None (невалидные)."""
+    batch = [x for x in batch if x is not None]
+    if not batch:
+        return None
+
+    audios = [b["audio"] for b in batch]
+    audio_tensor = torch.stack(audios)
+
+    labels = [b["label"] for b in batch]
+    label_tensor = torch.stack(labels)
+
+    texts = [b["text"] for b in batch]
+
+    return {
+        "audio": audio_tensor,
+        "label": label_tensor,
+        "text": texts
+    }
+
+def get_class_weights_from_loader(train_loader, num_classes):
+    """
+    Вычисляет веса классов из train_loader, устойчиво к отсутствующим классам.
+    Если какой-либо класс отсутствует в выборке, ему будет присвоен вес 0.0.
+
+    :param train_loader: DataLoader с one-hot метками
+    :param num_classes: Общее количество классов
+    :return: np.ndarray весов длины num_classes
+    """
+    all_labels = []
+    for batch in train_loader:
+        if batch is None:
+            continue
+        all_labels.extend(batch["label"].argmax(dim=1).tolist())
+
+    if not all_labels:
+        raise ValueError("Нет ни одной метки в train_loader для вычисления весов классов.")
+
+    present_classes = np.unique(all_labels)
+
+    if len(present_classes) < num_classes:
+        missing = set(range(num_classes)) - set(present_classes)
+        logging.info(f"[!] Отсутствуют метки для классов: {sorted(missing)}")
+
+    # Вычисляем веса только по тем классам, что есть
+    weights_partial = compute_class_weight(
+        class_weight="balanced",
+        classes=present_classes,
+        y=all_labels
+    )
+
+    # Собираем полный вектор весов
+    full_weights = np.zeros(num_classes, dtype=np.float32)
+    for cls, w in zip(present_classes, weights_partial):
+        full_weights[cls] = w
+
+    return full_weights
+
+def make_dataset_and_loader(config, split: str, only_dataset: str = None):
+    """
+    Универсальная функция: объединяет датасеты, или возвращает один при only_dataset.
+    """
+    datasets = []
+
+    if not hasattr(config, "datasets") or not config.datasets:
+        raise ValueError("⛔ В конфиге не указана секция [datasets].")
+
+    for dataset_name, dataset_cfg in config.datasets.items():
+        if only_dataset and dataset_name != only_dataset:
+            continue
+
+        csv_path = dataset_cfg["csv_path"].format(base_dir=dataset_cfg["base_dir"], split=split)
+        wav_dir  = dataset_cfg["wav_dir"].format(base_dir=dataset_cfg["base_dir"], split=split)
+
+        logging.info(f"[{dataset_name.upper()}] Split={split}: CSV={csv_path}, WAV_DIR={wav_dir}")
+
+        dataset = DatasetMultiModal(
+            csv_path = csv_path,
+            wav_dir  = wav_dir,
+            emotion_columns = config.emotion_columns,
+            split          = split,
+            sample_rate    = config.sample_rate,
+            wav_length     = config.wav_length,
+            whisper_model  = config.whisper_model,
+            text_column    = config.text_column,
+            use_whisper_for_nontrain_if_no_text = config.use_whisper_for_nontrain_if_no_text,
+            whisper_device = config.whisper_device,
+            subset_size    = config.subset_size,
+            merge_probability = config.merge_probability
+        )
+
+        datasets.append(dataset)
+
+    if not datasets:
+        raise ValueError(f"⚠️ Для split='{split}' не найдено ни одного подходящего датасета.")
+
+    # Объединяем только если их несколько
+    full_dataset = datasets[0] if len(datasets) == 1 else ConcatDataset(datasets)
+
+    loader = DataLoader(
+        full_dataset,
+        batch_size=config.batch_size,
+        shuffle=(split == "train"),
+        num_workers=config.num_workers,
+        collate_fn=custom_collate_fn
+    )
+
+    return full_dataset, loader
+
+def run_eval(model, loader, audio_extractor, text_extractor, criterion, device="cuda"):
+    """
+    Оценка модели на loader'е. Возвращае�� (loss, uar, war, mf1, wf1).
+    """
+    model.eval()
+    total_loss = 0.0
+    total_preds = []
+    total_targets = []
+    total = 0
+
+    with torch.no_grad():
+        for batch in tqdm(loader):
+            if batch is None:
+                continue
+
+            audio  = batch["audio"].to(device)
+            labels = batch["label"].to(device)
+            texts  = batch["text"]
+
+            audio_emb = audio_extractor.extract(audio)
+            text_emb  = text_extractor.extract(texts)
+
+            logits = model(audio_emb, text_emb)
+            target = labels.argmax(dim=1)
+
+            loss = criterion(logits, target)
+            bs = audio.shape[0]
+            total_loss += loss.item() * bs
+            total += bs
+
+            preds = logits.argmax(dim=1)
+            total_preds.extend(preds.cpu().numpy().tolist())
+            total_targets.extend(target.cpu().numpy().tolist())
+
+    avg_loss = total_loss / total
+
+    uar_m = uar(total_targets, total_preds)
+    war_m = war(total_targets, total_preds)
+    mf1_m = mf1(total_targets, total_preds)
+    wf1_m = wf1(total_targets, total_preds)
+
+    return avg_loss, uar_m, war_m, mf1_m, wf1_m
+
+def train_once(config, train_loader, dev_loaders, test_loaders, metrics_csv_path=None):
+    """
+    Логика обучения (train/dev/test).
+    Возвращает лучшую метрику на dev и словарь метрик.
+    """
+
+    logging.info("== Запуск тренировки (train/dev/test) ==")
+
+    csv_writer = None
+    csv_file = None
+
+    if metrics_csv_path:
+        csv_file = open(metrics_csv_path, mode="w", newline="", encoding="utf-8")
+        csv_writer = csv.writer(csv_file)
+        csv_writer.writerow(["split", "epoch", "dataset", "loss", "uar", "war", "mf1", "wf1", "mean"])
+
+
+    # Seed
+    if config.random_seed > 0:
+        random.seed(config.random_seed)
+        torch.manual_seed(config.random_seed)
+        logging.info(f"== Фиксируем random seed: {config.random_seed}")
+    else:
+        logging.info("== Random seed не фиксирован (0).")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # Экстракторы
+    audio_extractor = AudioEmbeddingExtractor(config)
+    text_extractor  = TextEmbeddingExtractor(config)
+
+    # Параметры
+    hidden_dim            = config.hidden_dim
+    num_classes           = len(config.emotion_columns)
+    num_transformer_heads = config.num_transformer_heads
+    num_graph_heads       = config.num_graph_heads
+    hidden_dim_gated      = config.hidden_dim_gated
+    mode                  = config.mode
+    positional_encoding   = config.positional_encoding
+    dropout               = config.dropout
+    out_features          = config.out_features
+    lr                    = config.lr
+    num_epochs            = config.num_epochs
+    tr_layer_number       = config.tr_layer_number
+    max_patience          = config.max_patience
+
+    dict_models = {
+        'BiFormer': BiFormer,
+        'BiGraphFormer': BiGraphFormer,
+        'BiGatedGraphFormer': BiGatedGraphFormer,
+        # 'MultiModalTransformer_v5': MultiModalTransformer_v5,
+        # 'MultiModalTransformer_v4': MultiModalTransformer_v4,
+        # 'MultiModalTransformer_v3': MultiModalTransformer_v3
+    }
+
+    model_cls = dict_models[config.model_name]
+    model = model_cls(
+        audio_dim             = config.audio_embedding_dim,
+        text_dim              = config.text_embedding_dim,
+        hidden_dim            = hidden_dim,
+        hidden_dim_gated      = hidden_dim_gated,
+        num_transformer_heads = num_transformer_heads,
+        num_graph_heads       = num_graph_heads,
+        seg_len               = config.max_tokens,
+        mode                  = mode,
+        dropout               = dropout,
+        positional_encoding   = positional_encoding,
+        out_features          = out_features,
+        tr_layer_number       = tr_layer_number,
+        device                = device,
+        num_classes           = num_classes
+    ).to(device)
+
+    # Оптимизатор и лосс
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+
+    class_weights = get_class_weights_from_loader(train_loader, num_classes)
+    criterion = WeightedCrossEntropyLoss(class_weights)
+
+    logging.info("Class weights: " + ", ".join(f"{name}={weight:.4f}" for name, weight in zip(config.emotion_columns, class_weights)))
+
+    # LR Scheduler
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+        optimizer,
+        mode="max",
+        factor=0.5,
+        patience=2,
+        min_lr=1e-7
+    )
+
+    # Early stopping по dev
+    best_dev_mean = float("-inf")
+    best_dev_metrics = {}
+    patience_counter = 0
+
+    for epoch in range(num_epochs):
+        logging.info(f"\n=== Эпоха {epoch} ===")
+        model.train()
+
+        total_loss = 0.0
+        total_samples = 0
+        total_preds = []
+        total_targets = []
+
+        for batch in tqdm(train_loader):
+            if batch is None:
+                continue
+
+            audio  = batch["audio"].to(device)
+            labels = batch["label"].to(device)
+            texts  = batch["text"]
+
+            audio_emb = audio_extractor.extract(audio)
+            text_emb  = text_extractor.extract(texts)
+
+            logits = model(audio_emb, text_emb)
+            target = labels.argmax(dim=1)
+            loss   = criterion(logits, target)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+            bs = audio.shape[0]
+            total_loss += loss.item() * bs
+
+            preds = logits.argmax(dim=1)
+            total_preds.extend(preds.cpu().numpy().tolist())
+            total_targets.extend(target.cpu().numpy().tolist())
+            total_samples += bs
+
+        train_loss = total_loss / total_samples
+        uar_m = uar(total_targets, total_preds)
+        war_m = war(total_targets, total_preds)
+        mf1_m = mf1(total_targets, total_preds)
+        wf1_m = wf1(total_targets, total_preds)
+        mean_train = np.mean([uar_m, war_m, mf1_m, wf1_m])
+
+        logging.info(
+            f"[TRAIN] Loss={train_loss:.4f}, UAR={uar_m:.4f}, WAR={war_m:.4f}, "
+            f"MF1={mf1_m:.4f}, WF1={wf1_m:.4f}, MEAN={mean_train:.4f}"
+        )
+
+        # --- DEV ---
+        dev_means = []
+        dev_metrics_by_dataset = []
+
+        for name, loader in dev_loaders:
+            d_loss, d_uar, d_war, d_mf1, d_wf1 = run_eval(
+                model, loader, audio_extractor, text_extractor, criterion, device
+            )
+            d_mean = np.mean([d_uar, d_war, d_mf1, d_wf1])
+            dev_means.append(d_mean)
+
+            if csv_writer:
+                csv_writer.writerow(["dev", epoch, name, d_loss, d_uar, d_war, d_mf1, d_wf1, d_mean])
+
+            logging.info(
+                f"[DEV:{name}] Loss={d_loss:.4f}, UAR={d_uar:.4f}, WAR={d_war:.4f}, "
+                f"MF1={d_mf1:.4f}, WF1={d_wf1:.4f}, MEAN={d_mean:.4f}"
+            )
+
+            dev_metrics_by_dataset.append({
+                "name": name,
+                "loss": d_loss,
+                "uar": d_uar,
+                "war": d_war,
+                "mf1": d_mf1,
+                "wf1": d_wf1,
+                "mean": d_mean,
+            })
+
+        mean_dev = np.mean(dev_means)
+        scheduler.step(mean_dev)
+
+        if mean_dev > best_dev_mean:
+            best_dev_mean = mean_dev
+            patience_counter = 0
+            best_dev_metrics = {
+                "mean": mean_dev
+            }
+            best_dev_metrics["by_dataset"] = dev_metrics_by_dataset
+        else:
+            patience_counter += 1
+            if patience_counter >= max_patience:
+                logging.info(f"Early stopping: {max_patience} эпох без улучшения.")
+                break
+
+        # --- TEST ---
+        for name, loader in test_loaders:
+            t_loss, t_uar, t_war, t_mf1, t_wf1 = run_eval(
+                model, loader, audio_extractor, text_extractor, criterion, device
+            )
+            t_mean = np.mean([t_uar, t_war, t_mf1, t_wf1])
+            logging.info(
+                f"[TEST:{name}] Loss={t_loss:.4f}, UAR={t_uar:.4f}, WAR={t_war:.4f}, "
+                f"MF1={t_mf1:.4f}, WF1={t_wf1:.4f}, MEAN={t_mean:.4f}"
+            )
+
+            if csv_writer:
+                csv_writer.writerow(["test", epoch, name, t_loss, t_uar, t_war, t_mf1, t_wf1, t_mean])
+
+    if csv_file:
+        csv_file.close()
+
+    logging.info("Тренировка завершена. Все split'ы обработаны!")
+    return best_dev_mean, best_dev_metrics

utils/config_loader.py

@@ -0,0 +1,204 @@
+# utils/config_loader.py
+
+import os
+import toml
+import logging
+
+class ConfigLoader:
+    """
+    Класс для загрузки и обработки конфигурации из `config.toml`.
+    """
+
+    def __init__(self, config_path="config.toml"):
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"Файл конфигурации `{config_path}` не найден!")
+
+        self.config = toml.load(config_path)
+
+        # ---------------------------
+        # Общие параметры
+        # ---------------------------
+        self.split = self.config.get("split", "train")
+
+        # ---------------------------
+        # Пути к данным
+        # ---------------------------
+        self.datasets = self.config.get("datasets", {})
+
+        # ---------------------------
+        # Пути к синтетическим данным
+        # ---------------------------
+        synthetic_data_cfg = self.config.get("synthetic_data", {})
+        self.use_synthetic_data = synthetic_data_cfg.get("use_synthetic_data", False)
+        self.synthetic_path = synthetic_data_cfg.get("synthetic_path", "E:/MELD_S")
+        self.synthetic_ratio = synthetic_data_cfg.get("synthetic_ratio", 0.0)
+
+        # ---------------------------
+        # Модальности и эмоции
+        # ---------------------------
+        self.modalities = self.config.get("modalities", ["audio"])
+        self.emotion_columns = self.config.get("emotion_columns", ["anger", "disgust", "fear", "happy", "neutral", "sad", "surprise"])
+
+        # ---------------------------
+        # DataLoader
+        # ---------------------------
+        dataloader_cfg = self.config.get("dataloader", {})
+        self.num_workers = dataloader_cfg.get("num_workers", 0)
+        self.shuffle = dataloader_cfg.get("shuffle", True)
+        self.prepare_only = dataloader_cfg.get("prepare_only", False)
+
+        # ---------------------------
+        # Аудио
+        # ---------------------------
+        audio_cfg = self.config.get("audio", {})
+        self.sample_rate = audio_cfg.get("sample_rate", 16000)
+        self.wav_length = audio_cfg.get("wav_length", 2)
+        self.save_merged_audio = audio_cfg.get("save_merged_audio", True)
+        self.merged_audio_base_path = audio_cfg.get("merged_audio_base_path", "saved_merges")
+        self.merged_audio_suffix = audio_cfg.get("merged_audio_suffix", "_merged")
+        self.force_remerge = audio_cfg.get("force_remerge", False)
+
+        # ---------------------------
+        # Whisper / Текст
+        # ---------------------------
+        text_cfg = self.config.get("text", {})
+        self.text_source = text_cfg.get("source", "csv")
+        self.text_column = text_cfg.get("text_column", "text")
+        self.whisper_model = text_cfg.get("whisper_model", "tiny")
+        self.max_text_tokens = text_cfg.get("max_tokens", 15)
+        self.whisper_device = text_cfg.get("whisper_device", "cuda")
+        self.use_whisper_for_nontrain_if_no_text = text_cfg.get("use_whisper_for_nontrain_if_no_text", True)
+
+        # ---------------------------
+        # Тренировка: общие
+        # ---------------------------
+        train_general = self.config.get("train", {}).get("general", {})
+        self.random_seed = train_general.get("random_seed", 42)
+        self.subset_size = train_general.get("subset_size", 0)
+        self.merge_probability = train_general.get("merge_probability", 0)
+        self.batch_size = train_general.get("batch_size", 8)
+        self.num_epochs = train_general.get("num_epochs", 100)
+        self.max_patience = train_general.get("max_patience", 10)
+        self.save_best_model = train_general.get("save_best_model", False)
+        self.save_prepared_data = train_general.get("save_prepared_data", True)
+        self.save_feature_path = train_general.get("save_feature_path", "./features/")
+        self.search_type = train_general.get("search_type", "none")
+        self.smoothing_probability = train_general.get("smoothing_probability", 0)
+        self.path_to_df_ls = train_general.get("path_to_df_ls", None)
+
+        # ---------------------------
+        # Тренировка: параметры модели
+        # ---------------------------
+        train_model = self.config.get("train", {}).get("model", {})
+        self.model_name = train_model.get("model_name", "BiFormer")
+        self.hidden_dim = train_model.get("hidden_dim", 256)
+        self.hidden_dim_gated = train_model.get("hidden_dim_gated", 256)
+        self.num_transformer_heads = train_model.get("num_transformer_heads", 8)
+        self.num_graph_heads = train_model.get("num_graph_heads", 8)
+        self.tr_layer_number = train_model.get("tr_layer_number", 1)
+        self.mamba_d_state = train_model.get("mamba_d_state", 16)
+        self.mamba_ker_size = train_model.get("mamba_ker_size", 4)
+        self.mamba_layer_number = train_model.get("mamba_layer_number", 3)
+        self.positional_encoding = train_model.get("positional_encoding", True)
+        self.dropout = train_model.get("dropout", 0.0)
+        self.out_features = train_model.get("out_features", 128)
+        self.mode = train_model.get("mode", "mean")
+
+        # ---------------------------
+        # Тренировка: оптимизатор
+        # ---------------------------
+        train_optimizer = self.config.get("train", {}).get("optimizer", {})
+        self.optimizer = train_optimizer.get("optimizer", "adam")
+        self.lr = train_optimizer.get("lr", 1e-4)
+        self.weight_decay = train_optimizer.get("weight_decay", 0.0)
+        self.momentum = train_optimizer.get("momentum", 0.9)
+
+        # ---------------------------
+        # Тренировка: шедулер
+        # ---------------------------
+        train_scheduler = self.config.get("train", {}).get("scheduler", {})
+        self.scheduler_type = train_scheduler.get("scheduler_type", "plateau")
+        self.warmup_ratio = train_scheduler.get("warmup_ratio", 0.1)
+
+        # ---------------------------
+        # Эмбеддинги
+        # ---------------------------
+        emb_cfg = self.config.get("embeddings", {})
+        self.audio_model_name = emb_cfg.get("audio_model", "amiriparian/ExHuBERT")
+        self.text_model_name  = emb_cfg.get("text_model", "jinaai/jina-embeddings-v3")
+        self.audio_classifier_checkpoint = emb_cfg.get("audio_classifier_checkpoint", "best_audio_model.pt")
+        self.text_classifier_checkpoint = emb_cfg.get("text_classifier_checkpoint", "best_text_model.pth")
+        self.audio_embedding_dim = emb_cfg.get("audio_embedding_dim", 1024)
+        self.text_embedding_dim  = emb_cfg.get("text_embedding_dim", 1024)
+        self.emb_normalize = emb_cfg.get("emb_normalize", True)
+        self.audio_pooling = emb_cfg.get("audio_pooling", None)
+        self.text_pooling  = emb_cfg.get("text_pooling", None)
+        self.max_tokens = emb_cfg.get("max_tokens", 256)
+        self.emb_device = emb_cfg.get("device", "cuda")
+
+        # ---------------------------
+        # Синтетика
+        # ---------------------------
+        # textgen_cfg = self.config.get("textgen", {})
+        # self.model_name = textgen_cfg.get("model_name", "deepseek-ai/DeepSeek-R1-Distill-Llama-8B")
+        # self.max_new_tokens = textgen_cfg.get("max_new_tokens", 50)
+        # self.temperature = textgen_cfg.get("temperature", 1.0)
+        # self.top_p = textgen_cfg.get("top_p", 0.95)
+
+        if __name__ == "__main__":
+            self.log_config()
+
+    def log_config(self):
+        logging.info("=== CONFIGURATION ===")
+        logging.info(f"Split: {self.split}")
+        logging.info(f"Datasets loaded: {list(self.datasets.keys())}")
+        for name, ds in self.datasets.items():
+            logging.info(f"[Dataset: {name}]")
+            logging.info(f"  Base Dir: {ds.get('base_dir', 'N/A')}")
+            logging.info(f"  CSV Path: {ds.get('csv_path', '')}")
+            logging.info(f"  WAV Dir: {ds.get('wav_dir', '')}")
+        logging.info(f"Emotion columns: {self.emotion_columns}")
+
+        # Логируем обучающие параметры
+        logging.info("--- Training Config ---")
+        logging.info(f"Sample Rate={self.sample_rate}, Wav Length={self.wav_length}s")
+        logging.info(f"Whisper Model={self.whisper_model}, Device={self.whisper_device}, MaxTokens={self.max_text_tokens}")
+        logging.info(f"use_whisper_for_nontrain_if_no_text={self.use_whisper_for_nontrain_if_no_text}")
+        logging.info(f"DataLoader: batch_size={self.batch_size}, num_workers={self.num_workers}, shuffle={self.shuffle}")
+        logging.info(f"Model Name: {self.model_name}")
+        logging.info(f"Random Seed: {self.random_seed}")
+        logging.info(f"Hidden Dim: {self.hidden_dim}")
+        logging.info(f"Hidden Dim in Gated: {self.hidden_dim_gated}")
+        logging.info(f"Num Heads in Transformer: {self.num_transformer_heads}")
+        logging.info(f"Num Heads in Graph: {self.num_graph_heads}")
+        logging.info(f"Mode stat pooling: {self.mode}")
+        logging.info(f"Optimizer: {self.optimizer}")
+        logging.info(f"Scheduler Type: {self.scheduler_type}")
+        logging.info(f"Warmup Ratio: {self.warmup_ratio}")
+        logging.info(f"Weight Decay for Adam: {self.weight_decay}")
+        logging.info(f"Momentum (SGD): {self.momentum}")
+        logging.info(f"Positional Encoding: {self.positional_encoding}")
+        logging.info(f"Number of Transformer Layers: {self.tr_layer_number}")
+        logging.info(f"Mamba D State: {self.mamba_d_state}")
+        logging.info(f"Mamba Kernel Size: {self.mamba_ker_size}")
+        logging.info(f"Mamba Layer Number: {self.mamba_layer_number}")
+        logging.info(f"Dropout: {self.dropout}")
+        logging.info(f"Out Features: {self.out_features}")
+        logging.info(f"LR: {self.lr}")
+        logging.info(f"Num Epochs: {self.num_epochs}")
+        logging.info(f"Merge Probability={self.merge_probability}")
+        logging.info(f"Smoothing Probability={self.smoothing_probability}")
+        logging.info(f"Max Patience={self.max_patience}")
+        logging.info(f"Save Prepared Data={self.save_prepared_data}")
+        logging.info(f"Path to Save Features={self.save_feature_path}")
+        logging.info(f"Search Type={self.search_type}")
+
+        # Логируем embeddings
+        logging.info("--- Embeddings Config ---")
+        logging.info(f"Audio Model: {self.audio_model_name}, Text Model: {self.text_model_name}")
+        logging.info(f"Audio dim={self.audio_embedding_dim}, Text dim={self.text_embedding_dim}")
+        logging.info(f"Audio pooling={self.audio_pooling}, Text pooling={self.text_pooling}")
+        logging.info(f"Emb device={self.emb_device}, Normalize={self.emb_normalize}")
+
+    def show_config(self):
+        self.log_config()

utils/logger_setup.py

@@ -0,0 +1,47 @@
+# utils/logger_setup.py
+
+import logging
+from colorlog import ColoredFormatter
+
+def setup_logger(level=logging.INFO, log_file=None):
+    """
+    Настраивает корневой логгер для вывода цветных логов в консоль и
+    (опционально) записи в файл.
+
+    :param level: Уровень логирования (например, logging.DEBUG)
+    :param log_file: Путь к файлу лога (если не None, логи будут писаться в этот файл)
+    """
+    logger = logging.getLogger()
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # Консольный хендлер с colorlog
+    console_handler = logging.StreamHandler()
+    log_format = (
+        "%(log_color)s%(asctime)s [%(levelname)s]%(reset)s %(blue)s%(message)s"
+    )
+    console_formatter = ColoredFormatter(
+        log_format,
+        datefmt="%Y-%m-%d %H:%M:%S",
+        reset=True,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "bold_red"
+        }
+    )
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+
+    # Если указан log_file, добавляем файловый хендлер
+    if log_file is not None:
+        file_handler = logging.FileHandler(log_file, mode="w", encoding="utf-8")
+        file_format = "%(asctime)s [%(levelname)s] %(message)s"
+        file_formatter = logging.Formatter(file_format, datefmt="%Y-%m-%d %H:%M:%S")
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    logger.setLevel(level)
+    return logger

utils/losses.py

@@ -0,0 +1,33 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class WeightedCrossEntropyLoss(nn.Module):
+    def __init__(self, class_weights=None):
+        """
+        Инициализация класса для кросс-энтропийной потери с возможностью взвешивания классов.
+
+        :param class_weights: Вектор весов для классов (опционально)
+        """
+        super(WeightedCrossEntropyLoss, self).__init__()
+        self.class_weights = class_weights
+
+    def forward(self, y_pred, y_true):
+        """
+        Вычисление кросс-энтропийной потери с (или без) взвешиванием классов.
+
+        :param y_true: Точные метки классов (вектор или одна метка)
+        :param y_pred: Вероятностный вектор предсказаний
+        :return: Значение потери
+        """
+
+        y_true = y_true.to(torch.long)  # Приводим метки к типу Long
+        y_pred = y_pred.to(torch.float32)  # Приводим предсказания к типу Float32
+
+        if self.class_weights is not None:
+            class_weights = torch.tensor(self.class_weights).float().to(y_true.device)
+            loss = F.cross_entropy(y_pred, y_true, weight=class_weights)
+        else:
+            loss = F.cross_entropy(y_pred, y_true)
+        
+        return loss

utils/measures.py

@@ -0,0 +1,41 @@
+from sklearn.metrics import recall_score, f1_score
+
+def uar(y_true, y_pred):
+    """
+    Вычисление метрики UAR (Unweighted Average Recall).
+    
+    :param y_true: Истинные метки
+    :param y_pred: Предсказанные метки
+    :return: UAR (Recall по всем классам без учета веса)
+    """
+    return recall_score(y_true, y_pred, average='macro', zero_division=0)
+
+def war(y_true, y_pred):
+    """
+    Вычисление метрики WAR (Weighted Average Recall).
+    
+    :param y_true: Истинные метки
+    :param y_pred: Предсказанные метки
+    :return: WAR (Recall с учетом веса классов)
+    """
+    return recall_score(y_true, y_pred, average='weighted', zero_division=0)
+
+def mf1(y_true, y_pred):
+    """
+    Вычисление метрики MF1 (Macro F1 Score).
+    
+    :param y_true: Истинные метки
+    :param y_pred: Предсказанные метки
+    :return: MF1 (F1 с усреднением по всем классам)
+    """
+    return f1_score(y_true, y_pred, average='macro', zero_division=0)
+
+def wf1(y_true, y_pred):
+    """
+    Вычисление метрики WFI (Weighted F1 Score).
+    
+    :param y_true: Истинные метки
+    :param y_pred: Предсказанные метки
+    :return: WFI (F1 с учетом веса классов)
+    """
+    return f1_score(y_true, y_pred, average='weighted', zero_division=0)