Upload 3 files

kaggle_preprocessing_starter.py

@@ -0,0 +1,630 @@
+# -*- coding: utf-8 -*-
+"""kaggle_preprocessing_starter.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1Jzz9VWmE7n-HcdrXTuutXKHvAA1ry-5a
+
+# Kaggle Starter Notebook
+Базовые предобработки данных + быстрый старт моделей.
+
+# 🔥 Kaggle Starter Template: Предобработка + Генерация признаков + Модели
+
+Полный набор методов предобработки, генерации признаков, feature selection и моделей для соревнований Kaggle.  
+Каждый метод снабжён пояснением.
+
+---
+
+## 1. 🟦 Категориальные признаки
+
+### 1.1 OneHotEncoding (OHE)
+**Что делает:** Преобразует категорию в бинарные колонки.  
+**Когда использовать:** Для линейных моделей, где порядок категорий не важен.
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+import pandas as pd
+
+ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
+ohe_df = pd.DataFrame(ohe.fit_transform(df[['cat']]),
+                      columns=ohe.get_feature_names_out(['cat']))
+````
+
+### 1.2 LabelEncoding
+
+**Что делает:** Каждой категории присваивается число.
+**Когда использовать:** Для деревьев (RandomForest, XGBoost), избегать для линейных моделей.
+
+```python
+from sklearn.preprocessing import LabelEncoder
+le = LabelEncoder()
+df['cat_le'] = le.fit_transform(df['cat'])
+```
+
+### 1.3 Target Encoding
+
+**Что делает:** Каждой категории присваивается среднее значение таргета.
+**Когда использовать:** Для категорий с сильной зависимостью от цели.
+**Внимание:** Возможна утечка информации, используйте KFold.
+
+```python
+!pip install category_encoders
+from category_encoders import TargetEncoder
+
+te = TargetEncoder()
+df['cat_te'] = te.fit_transform(df['cat'], df['target'])
+```
+
+### 1.4 CatBoostEncoder
+
+**Что делает:** Улучшенный target encoding с регуляризацией и шумом.
+**Когда использовать:** Для уменьшения переобучения на малых выборках.
+
+```python
+from category_encoders import CatBoostEncoder
+
+cbe = CatBoostEncoder()
+df['cat_cbe'] = cbe.fit_transform(df['cat'], df['target'])
+```
+
+### 1.5 Binary Encoding
+
+**Что делает:** Преобразует категорию в бинарный код.
+**Когда использовать:** Когда категорий слишком много для OHE.
+
+```python
+from category_encoders import BinaryEncoder
+
+be = BinaryEncoder()
+be_df = be.fit_transform(df['cat'])
+```
+
+---
+
+## 2. 🟩 Числовые признаки
+
+### 2.1 StandardScaler
+
+**Что делает:** Приводит к нулевому среднему и единичной дисперсии.
+**Когда использовать:** Для большинства моделей.
+
+```python
+from sklearn.preprocessing import StandardScaler
+df['scaled'] = StandardScaler().fit_transform(df[['num']])
+```
+
+### 2.2 RobustScaler
+
+**Что делает:** Масштабирование через медиану и IQR.
+**Когда использовать:** Если есть выбросы.
+
+```python
+from sklearn.preprocessing import RobustScaler
+df['r_scaled'] = RobustScaler().fit_transform(df[['num']])
+```
+
+### 2.3 MinMaxScaler
+
+**Что делает:** Масштабирует в диапазон [0,1].
+**Когда использовать:** Для нейронных сетей.
+
+```python
+from sklearn.preprocessing import MinMaxScaler
+df['minmax'] = MinMaxScaler().fit_transform(df[['num']])
+```
+
+### 2.4 PowerTransformer
+
+**Что делает:** Нормализует распределение признака (Box-Cox / Yeo-Johnson).
+**Когда использовать:** Для сильно скошенных данных.
+
+```python
+from sklearn.preprocessing import PowerTransformer
+df['pt'] = PowerTransformer(method='yeo-johnson').fit_transform(df[['num']])
+```
+
+---
+
+## 3. 🟧 Текстовые признаки
+
+### 3.1 TF-IDF
+
+**Что делает:** Преобразует текст в числовые векторы с учётом важности слов.
+**Когда использовать:** Для NLP-задач, классификации текста.
+
+```python
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+tfidf = TfidfVectorizer(max_features=5000, ngram_range=(1,2))
+tfidf_df = pd.DataFrame(tfidf.fit_transform(df['text']).toarray(),
+                        columns=tfidf.get_feature_names_out())
+```
+
+### 3.2 CountVectorizer
+
+**Что делает:** Считает количество слов.
+**Когда использовать:** Простая модель Bag-of-Words.
+
+```python
+from sklearn.feature_extraction.text import CountVectorizer
+
+cv = CountVectorizer(max_features=3000)
+cv_df = pd.DataFrame(cv.fit_transform(df['text']).toarray(),
+                     columns=cv.get_feature_names_out())
+```
+
+### 3.3 Word2Vec (Gensim)
+
+**Что делает:** Преобразует слова в векторы с помощью нейросети и усредняет по тексту.
+**Когда использовать:** Для семантических признаков текста.
+
+```python
+from gensim.models import Word2Vec
+import numpy as np
+
+w2v = Word2Vec(sentences=df['text'].str.split(), vector_size=100, window=5, min_count=1)
+df['w2v_mean'] = df['text'].str.split().apply(
+    lambda x: w2v.wv[x].mean(axis=0) if len(x)>0 else np.zeros(100))
+```
+
+---
+
+## 4. 🟪 Дата/время
+
+### 4.1 Извлечение компонентов даты
+
+**Что делает:** Получает год, месяц, день, день недели.
+**Когда использовать:** Для временных рядов или сезонных зависимостей.
+
+```python
+df['date'] = pd.to_datetime(df['date'])
+df['year'] = df['date'].dt.year
+df['month'] = df['date'].dt.month
+df['day'] = df['date'].dt.day
+df['dow'] = df['date'].dt.dayofweek
+df['is_weekend'] = df['dow'] >= 5
+```
+
+### 4.2 Циклические признаки для месяца/дня
+
+**Что делает:** Преобразует циклические признаки в син/кос для сохранения цикличности.
+
+```python
+import numpy as np
+df['month_sin'] = np.sin(2 * np.pi * df['month']/12)
+df['month_cos'] = np.cos(2 * np.pi * df['month']/12)
+```
+
+---
+
+## 5. 🟫 Статистические признаки и таймсериес
+
+### 5.1 Групповые агрегаты
+
+**Что делает:** Считает среднее, std, min, max по группам.
+**Когда использовать:** Для категориальных признаков, где важна статистика.
+
+```python
+group = df.groupby('cat')['num'].agg(['mean','std','min','max'])
+df = df.merge(group, on='cat', suffixes=('', '_grp'))
+```
+
+### 5.2 Lag / Shift
+
+**Что делает:** Берёт предыдущие значения временного ряда.
+**Когда использовать:** Для прогнозирования временных рядов.
+
+```python
+df['lag1'] = df['value'].shift(1)
+df['lag2'] = df['value'].shift(2)
+```
+
+### 5.3 Rolling / Скользящее окно
+
+**Что делает:** Считает агрегаты (mean, sum, std) по окну.
+**Когда использовать:** Для извлечения трендов в таймсериях.
+
+```python
+df['rolling_mean_3'] = df['value'].rolling(3).mean()
+df['rolling_std_3'] = df['value'].rolling(3).std()
+```
+
+---
+
+## 6. 🟨 Feature Selection
+
+### 6.1 Mutual Information
+
+**Что делает:** Оценивает зависимость признака и целевой переменной.
+**Когда использовать:** Для отбора информативных признаков.
+
+```python
+from sklearn.feature_selection import mutual_info_classif
+
+mi = mutual_info_classif(X, y)
+```
+
+### 6.2 SelectKBest
+
+**Что делает:** Выбирает K лучших признаков по метрике (ANOVA, MI и др.)
+
+```python
+from sklearn.feature_selection import SelectKBest, f_classif
+
+selector = SelectKBest(score_func=f_classif, k=20)
+X_new = selector.fit_transform(X, y)
+```
+
+### 6.3 RFE (Recursive Feature Elimination)
+
+**Что делает:** Рекурсивно удаляет наименее важные признаки, оставляя n лучших.
+**Когда использовать:** Для моделей с interpretability.
+
+```python
+from sklearn.feature_selection import RFE
+from sklearn.linear_model import LogisticRegression
+
+rfe = RFE(LogisticRegression(), n_features_to_select=10)
+rfe.fit(X, y)
+```
+
+---
+
+## 7. 🟫 Feature Generation
+
+### 7.1 Polynomial Features
+
+**Что делает:** Создаёт полиномиальные признаки (x^2, x*y).
+**Когда использовать:** Для линейных моделей, чтобы учесть нелинейности.
+
+```python
+from sklearn.preprocessing import PolynomialFeatures
+
+poly = PolynomialFeatures(degree=3)
+poly_df = pd.DataFrame(poly.fit_transform(df[['num1','num2']]))
+```
+
+### 7.2 Interaction Features
+
+**Что делает:** Создаёт признаки через перемножение/деление.
+**Когда использовать:** Для деревьев и линейных моделей.
+
+```python
+df['num1_x_num2'] = df['num1'] * df['num2']
+df['num1_div_num2'] = df['num1'] / (df['num2'] + 1e-5)
+```
+
+---
+
+## 8. 🔥 Модели: классификация
+
+```python
+from catboost import CatBoostClassifier
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, ExtraTreesClassifier
+from sklearn.svm import SVC
+```
+
+---
+
+## 9. 🔥 Модели: регрессия
+
+```python
+from xgboost import XGBRegressor
+from lightgbm import LGBMRegressor
+from catboost import CatBoostRegressor
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import LinearRegression, Ridge, Lasso
+```
+
+---
+
+## 10. 🧱 Полный Pipeline
+
+**Что делает:** Объединяет числовые, категориальные признаки, pre-processing и модель в один объект.
+
+```python
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from lightgbm import LGBMClassifier
+
+numeric = ['age','salary']
+categorical = ['city']
+
+preprocess = ColumnTransformer([
+    ('num', StandardScaler(), numeric),
+    ('cat', OneHotEncoder(handle_unknown='ignore'), categorical),
+])
+
+model = Pipeline([
+    ('prep', preprocess),
+    ('clf', LGBMClassifier())
+])
+
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+```
+
+```
+
+# 🧠 Продвинутое обучение моделей: классификация и регрессия
+
+## 1. Базовые модели
+
+### 1.1 Линейные модели
+
+**Логистическая регрессия (классификация)**
+```python
+from sklearn.linear_model import LogisticRegression
+
+clf = LogisticRegression(max_iter=1000)
+clf.fit(X_train, y_train)
+preds = clf.predict(X_test)
+````
+
+**Линейная регрессия (регрессия)**
+
+```python
+from sklearn.linear_model import LinearRegression
+
+reg = LinearRegression()
+reg.fit(X_train, y_train)
+preds = reg.predict(X_test)
+```
+
+**Ridge / Lasso (регуляризация)**
+
+```python
+from sklearn.linear_model import Ridge, Lasso
+
+ridge = Ridge(alpha=1.0)
+ridge.fit(X_train, y_train)
+
+lasso = Lasso(alpha=0.01)
+lasso.fit(X_train, y_train)
+```
+
+---
+
+### 1.2 Деревья и ансамбли
+
+**RandomForest**
+
+```python
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+
+rf_clf = RandomForestClassifier(n_estimators=200, max_depth=8, random_state=42)
+rf_clf.fit(X_train, y_train)
+
+rf_reg = RandomForestRegressor(n_estimators=200, max_depth=8, random_state=42)
+rf_reg.fit(X_train, y_train)
+```
+
+**Gradient Boosting**
+
+```python
+from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor
+
+gb_clf = GradientBoostingClassifier(n_estimators=300, learning_rate=0.05)
+gb_clf.fit(X_train, y_train)
+```
+
+---
+
+### 1.3 Популярные бустинги
+
+**XGBoost**
+
+```python
+from xgboost import XGBClassifier, XGBRegressor
+
+xgb_clf = XGBClassifier(n_estimators=300, learning_rate=0.05, max_depth=5, eval_metric='logloss')
+xgb_clf.fit(X_train, y_train)
+```
+
+**LightGBM**
+
+```python
+from lightgbm import LGBMClassifier, LGBMRegressor
+
+lgb_clf = LGBMClassifier(n_estimators=500, learning_rate=0.05, num_leaves=31)
+lgb_clf.fit(X_train, y_train)
+```
+
+**CatBoost**
+
+```python
+from catboost import CatBoostClassifier, CatBoostRegressor
+
+cat_clf = CatBoostClassifier(iterations=500, learning_rate=0.05, depth=6, verbose=0)
+cat_clf.fit(X_train, y_train)
+```
+
+---
+
+## 2. K-Fold Cross-Validation
+
+**Что делает:** Делит данные на K частей, обучает K моделей, усредняет метрики и предсказания.
+
+```python
+from sklearn.model_selection import KFold
+from sklearn.metrics import accuracy_score
+import numpy as np
+
+kf = KFold(n_splits=5, shuffle=True, random_state=42)
+oof_preds = np.zeros(len(X))
+for train_idx, val_idx in kf.split(X):
+    X_tr, X_val = X[train_idx], X[val_idx]
+    y_tr, y_val = y[train_idx], y[val_idx]
+    
+    model = LGBMClassifier(n_estimators=500)
+    model.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], early_stopping_rounds=50, verbose=0)
+    
+    oof_preds[val_idx] = model.predict(X_val)
+
+# Средняя точность
+from sklearn.metrics import accuracy_score
+accuracy_score(y, oof_preds)
+```
+
+**Пояснение:**
+
+* `early_stopping_rounds` помогает остановить обучение, если модель не улучшается
+* `shuffle=True` перемешивает данные для устойчивости
+
+---
+
+## 3. Метрики
+
+### 3.1 Классификация
+
+```python
+from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
+
+accuracy = accuracy_score(y_test, preds)
+f1 = f1_score(y_test, preds)
+roc_auc = roc_auc_score(y_test, probs[:,1])  # для бинарного случая
+```
+
+### 3.2 Регрессия
+
+```python
+from sklearn.metrics import mean_squared_error, r2_score
+
+mse = mean_squared_error(y_test, preds)
+rmse = np.sqrt(mse)
+r2 = r2_score(y_test, preds)
+```
+
+---
+
+## 4. Early Stopping (для бустингов)
+
+```python
+lgb_clf = LGBMClassifier(n_estimators=10000, learning_rate=0.01)
+lgb_clf.fit(
+    X_train, y_train,
+    eval_set=[(X_val, y_val)],
+    eval_metric='logloss',
+    early_stopping_rounds=100,
+    verbose=100
+)
+```
+
+---
+
+## 5. Stacking / Blending
+
+**Что делает:** Комбинирует предсказания нескольких моделей через meta-модель.
+
+```python
+from sklearn.ensemble import StackingClassifier
+from sklearn.linear_model import LogisticRegression
+
+estimators = [
+    ('rf', RandomForestClassifier(n_estimators=100)),
+    ('xgb', XGBClassifier(n_estimators=100)),
+    ('lgb', LGBMClassifier(n_estimators=100))
+]
+
+stack = StackingClassifier(
+    estimators=estimators,
+    final_estimator=LogisticRegression()
+)
+stack.fit(X_train, y_train)
+preds = stack.predict(X_test)
+```
+
+**Пояснение:**
+
+* Каждый базовый классификатор делает предсказания
+* Meta-модель (например, LogisticRegression) обучается на этих предсказаниях
+
+---
+
+## 6. Feature Importance
+
+**Для деревьев и бустингов:**
+
+```python
+import matplotlib.pyplot as plt
+
+model = LGBMClassifier(n_estimators=500)
+model.fit(X_train, y_train)
+
+feat_importances = pd.Series(model.feature_importances_, index=X.columns)
+feat_importances.nlargest(20).plot(kind='barh')
+plt.show()
+```
+
+**Пояснение:**
+
+* Позволяет увидеть, какие признаки влияют на модель
+* Можно отбирать топовые фичи для уменьшения размерности
+
+---
+
+## 7. Randomized Search / Grid Search (Подбор гиперпараметров)
+
+```python
+from sklearn.model_selection import RandomizedSearchCV
+
+param_grid = {
+    'n_estimators': [100, 300, 500],
+    'max_depth': [3, 5, 7],
+    'learning_rate': [0.01, 0.05, 0.1]
+}
+
+rs = RandomizedSearchCV(LGBMClassifier(), param_grid, cv=3, scoring='accuracy', n_iter=5)
+rs.fit(X_train, y_train)
+rs.best_params_
+```
+
+**Пояснение:**
+
+* Автоматически ищет лучшие гиперпараметры
+* `n_iter` контролирует количество проб
+
+---
+
+## 8. Пример пайплайна с K-Fold и несколькими моделями
+
+```python
+from sklearn.model_selection import KFold
+import numpy as np
+
+kf = KFold(n_splits=5, shuffle=True, random_state=42)
+oof_preds = np.zeros(len(X))
+models = []
+
+for train_idx, val_idx in kf.split(X):
+    X_tr, X_val = X[train_idx], X[val_idx]
+    y_tr, y_val = y[train_idx], y[val_idx]
+    
+    model = CatBoostClassifier(iterations=1000, learning_rate=0.05, depth=6, verbose=0)
+    model.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], early_stopping_rounds=50)
+    
+    oof_preds[val_idx] = model.predict(X_val)
+    models.append(model)
+
+accuracy_score(y, oof_preds)
+"""
+
+import numpy as np
+
+# Пример: n моделей
+preds_list = [pred1, pred2, pred3]  # список массивов предсказаний
+weights = np.array([2.0, 1.0, 3.0]) # твои исходные коэффициенты
+
+# Нормализуем коэффициенты
+weights = weights / weights.sum()
+
+# Усредняем предсказания
+final_pred = np.zeros_like(preds_list[0], dtype=float)
+
+for pred, w in zip(preds_list, weights):
+    final_pred += pred * w

nlp_general.py

@@ -0,0 +1,587 @@
+# -*- coding: utf-8 -*-
+"""NLP_GENERAL.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1g7CiQ8eJjVdDnZMoBWSOD01rHMVuQdC3
+
+# Классификация
+
+## Библиотеки и зависимости
+"""
+
+!pip install pymorphy2
+!pip install ufal.udpipe
+!pip install wget
+!pip install gensim
+!pip install umap-learn
+!pip install datashader
+!pip install bokeh
+!pip install holoviews
+!pip install yargy
+
+# Commented out IPython magic to ensure Python compatibility.
+import pandas as pd                                   # Для работы с датасетами
+import seaborn as sns                                 # Для визуализации
+import pymorphy2 as mph                               # Для лемметизации текста
+import re                                             # Регулярные выражения
+import wget                                           # Для загрузки файлов
+import sys                                            # Для испольнения системных команд
+from gensim.models import Word2Vec as w2v             # Для использования Word2vec
+import logging                                        # Для введения логов
+import string
+import nltk
+from nltk import word_tokenize                        # Для разбиения на токены
+from nltk.corpus import stopwords                     # Для удаления стоп-слов
+import random                                         # Для перемещивания данных
+import json                                           # Для сохранения массива
+import numpy as np                                    # Для линала
+import umap                                           # Для преобразования векторов из многомерного пространство в двухмерное
+import matplotlib.pyplot as plt                       # Для графиков
+# %matplotlib inline
+
+
+from yargy import Parser, rule, and_, or_             # Парсер
+from yargy.interpretation import fact, attribute      # Парсер
+from yargy.predicates import normalized, dictionary   # Парсер
+from yargy.pipelines import morph_pipeline            # Парсер
+from yargy.relations import main                      # Парсер
+from IPython.display import display                   # Парсер
+import spacy                                          # Парсер
+
+nltk.download('punkt')
+nltk.download('stopwords')
+sw = stopwords.words('russian')
+
+"""## Предобработка
+
+## 1. Предобработка текста
+
+
+* 1. ([Kaggle](https://www.kaggle.com/code/sudalairajkumar/getting-started-with-text-preprocessing)).
+* 2. (https://www.kaggle.com/code/abdmental01/text-preprocessing-nlp-steps-to-process-text)).
+* 3. (https://neptune.ai/blog/text-classification-tips-and-tricks-kaggle-competitions)
+
+Лемматизация
+
+
+---
+"""
+
+patterns = "[A-Za-z0-9!#$%&'()*+/:;<=>?@[\]^_`{|}~—\"]+"
+morph = mph.MorphAnalyzer()
+
+def lemmatize(doc):
+    doc = re.sub(patterns, ' ', doc)
+    tokens = []
+    for token in doc.split():
+        if token:
+            token = token.strip()
+            token = morph.normal_forms(token)[0]
+            tokens.append(token)
+    return ' '.join(tokens)
+
+"""Наташа
+
+
+---
+
+
+"""
+
+topic_name = []
+topic_one_to_one = []
+Case = fact('Case', ['name'])
+
+def make_topic(topic: list, name: str):
+    global topic_name
+
+    topic_name.append(morph_pipeline(topic).interpretation(
+          Case.name.const(name)
+      ).interpretation(
+          Case
+      )
+    )
+
+def make_topic_one_to_one(topic: list):
+    global topic_name
+
+    return morph_pipeline(topic).interpretation(
+          Case.name.normalized()
+      ).interpretation(
+          Case
+      )
+
+top_topic = [
+    (["окружность", "угол"], 'Геометрия'),
+
+    (["деление", "множители"], 'Многочлен'),
+
+    (["клетка", "закрасить"], 'Дирихле'),
+
+    (["делится", "оканчивается"], 'Теория чисел'),
+
+    (["способ", "разделить"], 'Комбинаторика'),
+
+    (["последовательность", "разрешаться"], 'Инвариант'),
+
+    (["сумма", "каждый", ], 'Оценка+Пример'),
+
+    (['город', "ребро",], 'Графы')
+]
+
+for name_complaint in top_topic:
+    make_topic(name_complaint[0], name_complaint[1])
+    topic_one_to_one.extend(list(name_complaint[0]))
+    for columns in list(name_complaint[0]):
+      data[columns] = np.NaN
+
+OTHERS = make_topic_one_to_one(topic_one_to_one)
+
+ALL = or_(*topic_name).interpretation(Case)
+OTHERS_ALL = or_(OTHERS).interpretation(Case)
+
+# Commented out IPython magic to ensure Python compatibility.
+# 
+# %%time
+# parser = Parser(OTHERS_ALL)
+# for ind, elem in enumerate(data['task']):
+#     for match in parser.findall(str(elem)):
+#         data.loc[ind, match.fact.name] = 1
+# 
+# parser = Parser(ALL)
+# for ind, elem in enumerate(data['task']):
+#     for match in parser.findall(str(elem)):
+#         data.loc[ind, match.fact.name] = 1
+
+"""Стоп слова"""
+
+# Commented out IPython magic to ensure Python compatibility.
+# Удаляем стоп-слова
+def remove_stopwords(lines, sw=sw):
+    res = []
+    for line in lines:
+        original = line
+        line = [w for w in line if w not in sw]
+        if len(line) < 1:
+            line = original
+        res.append(line)
+    return res
+
+# %time filtered_lines = remove_stopwords(lines=lines, sw=sw)
+
+"""Word2Vec"""
+
+# Commented out IPython magic to ensure Python compatibility.
+# Перемещиваем список
+random.shuffle(filtered_lines)
+# Обучаем word2vec
+# %time model = w2v(filtered_lines, min_count=3, sg=1, window=7)
+
+# Сохраняем модель
+model.save("word2vec.model")
+
+# Загружаем модель
+model = w2v.load("/content/drive/MyDrive/Проекты/Medsi/Models/word2vec.model")
+
+# Производим леммитизацию колокни
+merge_data_filter_2.illness_hostory = merge_data_filter_2.illness_hostory.apply(lemmatize)
+
+# Векторизируем
+for i in range(100):
+  merge_data_filter_2[f'vector_{i}'] = 0
+
+for j, text in enumerate(merge_data_filter_2['illness_hostory']):
+  vec = np.zeros(100)
+  lens = 0
+  for word in word_tokenize(text):
+      try:
+        vec += model.wv[word]
+        lens += 1
+      except KeyError:
+        continue
+
+  vec /= lens
+  for i in range(100):
+    merge_data_filter_2.iloc[j, 103+i] = vec[i]
+
+"""Umap"""
+
+import umap.plot
+
+mapper = umap.UMAP(densmap=True).fit(X)
+umap.plot.points(mapper)
+
+"""Фильтрация пунктуации"""
+
+def remove_punctuation(text):
+    translator = str.maketrans('', '', string.punctuation)
+    return text.translate(translator)
+
+"""Облако слов"""
+
+from wordcloud import WordCloud
+
+for topic in data.topic.unique():
+    df = data[data.topic == topic]
+    text = ' '.join(df['new_task'])
+    text_tokens = word_tokenize(text)
+
+    cloud = WordCloud(stopwords=stop_words,
+                      background_color='white').generate(' '.join(text_tokens))
+    plt.imshow(cloud)
+    plt.axis('off')
+    plt.title(topic)
+    plt.show()
+
+"""N-граммы"""
+
+k = 30
+n = 2
+for topic in data.topic.unique():
+    df = data[data.topic == topic]
+    words = ' '.join(df.new_task_pros)
+    words = ' '.join(list(filter(lambda x: len(x) >= 2, (words.split()))))
+    tokens = nltk.word_tokenize(words)
+
+    ngrams_list = list(ngrams(tokens, n))
+    freq_dist = dict(FreqDist(ngrams_list))
+    sorted_data = sorted(freq_dist.items(), key=lambda x: -x[1])
+
+    y_labels = [str(key) for key, _ in sorted_data][:k][::-1]
+    x_values = [value for _, value in sorted_data][:k][::-1]
+
+    plt.barh(y_labels, x_values)
+    plt.xlabel('Значение')
+    plt.ylabel('Кортежи')
+    plt.title(topic)
+    plt.show()
+
+"""TF-IDF"""
+
+def vect_tfidf(text):
+  return vectorizer.transform([text]).toarray()
+
+vectorizer = TfidfVectorizer(max_features=5000, min_df=3)
+X = vectorizer.fit_transform(learn_tf_idf)
+
+"""Tenserflow token"""
+
+vocab_size = 20000
+trunc_type = 'post'
+padding_type = 'post'
+embedding_dim = 128
+max_length = 120
+oov_tok = ''
+
+text = data['new_task']
+labels = data['y']
+tokenizer = Tokenizer(
+    num_words=vocab_size,
+    filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n',
+    lower=True,
+    oov_token=oov_tok
+)
+
+tokenizer.fit_on_texts(text)
+train_sequences = tokenizer.texts_to_sequences(text)
+train_padded = pad_sequences(
+    train_sequences,
+    maxlen=max_length,
+    padding=padding_type,
+    truncating=trunc_type
+)
+
+
+
+
+train_sequences = tokenizer.texts_to_sequences(data.new_task)
+train_padded = pad_sequences(train_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)
+
+
+for i in tqdm(range(max_length)):
+    data[f"Tokens f.{i + 1}"] = train_padded[:, i]
+
+"""## Finetune Bert"""
+
+!pip install transformers
+!pip install accelerate -U
+
+import torch
+import pandas as pd
+from transformers import AutoModelForSequenceClassification
+from transformers import BertTokenizerFast
+from transformers import TrainingArguments
+import torch, os
+import pandas as pd
+from transformers import pipeline, BertForSequenceClassification, BertTokenizerFast
+from torch.utils.data import Dataset
+
+import os
+import re
+import numpy as np
+import matplotlib.pyplot as plt
+import warnings
+import numpy as np
+import evaluate
+
+metric = evaluate.load("f1")
+warnings.filterwarnings('ignore')
+
+dataset = dataset[['task', 'topic']]
+dataset.rename(columns={'task': 'text',
+                        'topic': 'labels'},
+               inplace=True)
+NUM_LABELS = len(dataset.labels.unique())
+
+id2label = {id: label for id, label in enumerate(dataset.labels.unique())}
+
+label2id = {label: id for id, label in enumerate(dataset.labels.unique())}
+
+
+tokenizer = BertTokenizerFast.from_pretrained('blanchefort/rubert-base-cased-sentiment')
+model = BertForSequenceClassification.from_pretrained('blanchefort/rubert-base-cased-sentiment',
+                                                           num_labels=NUM_LABELS, id2label=id2label,
+                                                           label2id=label2id,
+                                                     ignore_mismatched_sizes=True)
+
+train_encodings = tokenizer(list(X_train), truncation=True, padding=True)
+val_encodings  = tokenizer(list(X_val), truncation=True, padding=True)
+test_encodings = tokenizer(list(X_test), truncation=True, padding=True)
+
+class DataLoader(Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+
+    def __getitem__(self, idx):
+        # Retrieve tokenized data for the given index
+        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
+        # Add the label for the given index to the item dictionary
+        item['labels'] = torch.tensor(self.labels[idx])
+        return item
+
+    def __len__(self):
+        return len(self.labels)
+
+train_dataloader = DataLoader(train_encodings, list(y_train))
+val_dataloader = DataLoader(val_encodings, list(y_val))
+test_dataset = DataLoader(test_encodings, list(y_test))
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataloader,
+    eval_dataset=val_dataloader,
+    compute_metrics=compute_metrics
+)
+
+
+trainer.train()
+
+def predict(text):
+    inputs = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors="pt").to("cuda")
+
+    outputs = model(**inputs)
+
+    probs = outputs[0].softmax(1)
+    pred_label_idx = probs.argmax()
+    pred_label = model.config.id2label[pred_label_idx.item()]
+
+    return probs, pred_label_idx, pred_label
+
+
+text = input()
+predict(text)
+
+"""## Text Classification: All Tips and Tricks from 5 Kaggle Competitions,
+
+1. Оптимизация памяти при работе с большими датасетами
+
+Использование Dask для чтения и обработки данных: https://dask.org/
+
+Использование cuDF для ускоренной обработки данных на GPU: https://docs.rapids.ai/api/cudf/stable/
+
+Конвертация данных в формат Parquet: https://parquet.apache.org/
+
+Конвертация данных в формат Feather: https://arrow.apache.org/docs/python/feather.html
+
+2. Методы увеличения данных (Data Augmentation)
+
+Замена слов синонимами для увеличения данных: https://towardsdatascience.com/data-augmentation-in-nlp-2801a34dfc28
+
+Добавление шума в тексты для обучения RNN: https://arxiv.org/abs/1703.02573
+
+Перевод текста на другие языки и обратно для создания новых примеров: https://arxiv.org/abs/1511.06709
+
+3. Исследование данных и получение инсайтов
+
+Простая разведывательная аналитика (EDA) для твитов: https://www.kaggle.com/code/ashishpatel26/simple-eda-for-tweets
+
+EDA для данных Quora: https://www.kaggle.com/code/sudalairajkumar/simple-eda-for-quora-question-pairs
+
+Полный EDA для данных Stack Exchange: https://www.kaggle.com/code/ashishpatel26/complete-eda-with-stack-exchange-data
+
+Предыдущая статья автора о EDA для обработки естественного языка: https://neptune.ai/blog/exploratory-data-analysis-nlp
+
+4. Очистка данных
+
+Использование TextBlob для исправления орфографических ошибок: https://textblob.readthedocs.io/en/dev/
+
+Предобработка для GloVe (часть 1): https://www.kaggle.com/code/ashishpatel26/preprocessing-for-glove-part-1
+
+Предобработка для GloVe (часть 2): https://www.kaggle.com/code/ashishpatel26/preprocessing-for-glove-part-2
+
+5. Представление текста
+
+Комбинирование предварительно обученных векторов для лучшего представления текста и уменьшения количества неизвестных слов: https://www.kaggle.com/code/ashishpatel26/combining-pre-trained-vectors
+
+Использование Universal Sentence Encoder для генерации признаков на уровне предложений: https://tfhub.dev/google/universal-sentence-encoder/4
+
+Три метода комбинирования эмбеддингов: https://www.kaggle.com/code/ashishpatel26/3-methods-to-combine-embeddings
+
+6. Архитектура модели
+
+Стекирование двух слоев LSTM/GRU для улучшения производительности: https://www.kaggle.com/code/ashishpatel26/stacking-2-layers-of-lstm-gru-networks
+
+7. Функции потерь
+
+Использование фокальной функции потерь для несбалансированных данных: https://arxiv.org/abs/1708.02002
+
+Пользовательская функция потерь "mimic loss", использованная в соревновании Jigsaw: https://www.kaggle.com/code/ashishpatel26/custom-mimic-loss-jigsaw
+
+Пользовательская функция потерь MTL, использованная в соревновании Jigsaw: https://www.kaggle.com/code/ashishpatel26/mtl-custom-loss-jigsaw
+
+8. Оптимизаторы
+
+Использование Adam с прогревом (warmup): https://www.kaggle.com/code/ashishpatel26/adam-with-warmup
+
+Использование BertAdam для моделей на основе BERT: https://www.kaggle.com/code/ashishpatel26/bert-adam
+
+Использование Rectified Adam для стабилизации обучения и ускорения сходимости: https://arxiv.org/abs/1908.03265
+
+9. Методы обратного вызова (Callbacks)
+
+Контрольная точка модели для мониторинга и сохранения весов: https://www.kaggle.com/code/ashishpatel26/model-checkpoint
+
+Планировщик скорости обучения для изменения скорости обучения на основе производительности модели: https://www.kaggle.com/code/ashishpatel26/learning-rate-scheduler
+
+Простые пользовательские обратные вызовы с использованием lambda-функций: https://www.kaggle.com/code/ashishpatel26/simple-custom-callbacks
+
+Пользовательская контрольная точка: https://www.kaggle.com/code/ashishpatel26/custom-checkpointing
+
+Создание собственных обратных вызовов для различных случаев использования: https://www.kaggle.com/code/ashishpatel26/building-custom-callbacks
+
+Уменьшение на плато для снижения скорости обучения, когда метрика перестает улучшаться: https://www.kaggle.com/code/ashishpatel26/reduce-on-plateau
+
+Раннее прекращение обучения при отсутствии улучшений: https://www.kaggle.com/code/ashishpatel26/early-stopping
+
+Снимок ансамблирования для получения различных контрольных точек модели в одном обучении: https://www.kaggle.com/code/ashishpatel26/snapshot-ensembling
+
+Быстрое геометрическое ансамблирование: https://www.kaggle.com/code/ashishpatel26/fast-geometric-ensembling
+
+Стохастическое усреднение весов (SWA): https://www.kaggle.com/code/ashishpatel26/stochastic-weight-averaging
+
+Динамическое уменьшение скорости обучения: https://www.kaggle.com/code/ashishpatel26/dynamic-learning-rate-decay
+
+10. Оценка и кросс-валидация
+
+K-кратная кросс-валидация: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html
+
+Стратифицированная K-кратная кросс-валидация: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html
+
+Групповая K-кратная кросс-валидация: https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GroupKFold.html
+
+Адвенсариальная валидация для проверки сходства распределений обучающего и тестового наборов: https://www.kaggle.com/code/ashishpatel26/adversarial-validation
+
+Анализ различных стратегий кросс-валидации: https://www.kaggle.com/code/ashishpatel26/cv-analysis-different-strategies
+
+11. Трюки для ускорения выполнения
+
+Сортировка последовательностей по длине для экономии времени выполнения и улучшения производительности: https://www.kaggle.com/code/ashishpatel26/sequence-bucketing
+
+Использование только начала и конца предложений, если длина превышает 512 токенов: https://www.kaggle.com/code/ashishpatel26/head-tail-trick
+
+Эффективное использование GPU: https://www.kaggle.com/code/ashishpatel26/use-gpu-efficiently
+
+Очистка памяти Keras: https://www.kaggle.com/code/ashishpatel26/free-keras-memory
+
+Сохранение и загрузка моделей для экономии времени и памяти: https://www.kaggle.com/code/ashishpatel26/save-load-models
+
+Не сохранять эмбеддинги в решениях на основе RNN: https://www.kaggle.com/code/ashishpatel26/dont-save-embedding-rnn
+
+Загрузка векторов word2vec без ключевых векторов: https://www.kaggle.com/code/ashishpatel26/load-word2vec-without-key-vectors
+
+12. Ансамблирование моделей
+
+Взвешенное среднее ансамблирование: https://www.kaggle.com/code/ashishpatel26/weighted-average-ensemble
+
+Стекированное обобщение (stacked generalization) ансамблирование: https://www.kaggle.com/code/ashishpatel26/stacked-generalization-ensemble
+
+Предсказания вне обучающего набора (out-of-fold predictions): https://www.kaggle.com/code/ashishpatel26/out-of-fold-predictions
+
+Смешивание с линейной регрессией: https://www.kaggle.com/code/ashishpatel26/blending-linear-regression
+
+Использование Optuna для определения весов смешивания: https://optuna.org/
+
+Среднее по степени (power average) ансамблирование: https://www.kaggle.com/code/ashishpatel26/power-average-ensemble
+
+Стратегия смешивания с использованием степени 3.5: https://www.kaggle.com/code/ashishpatel26/power-3-5-blending-strategy
+
+# Генерация
+
+📌 Когда использовать что
+
+| Сценарий                                             | Подход                                         |
+| ---------------------------------------------------- | ---------------------------------------------- |
+| Маленькие датасеты, учебные задачи                   | RNN / LSTM                                     |
+| Длинные последовательности, умеренные ресурсы        | LSTM (для стабильности) или GRU (для скорости) |
+| Требуется копирование или внимание к части входа     | RNN + Attention                                |
+| Лучшее качество, много данных и ресурсов             | Полное дообучение трансформеров                |
+| Большая модель, но мало памяти (например, 16 ГБ GPU) | LoRA / QLoRA                                   |
+| Несколько задач на одной базе                        | Adapters или Prefix Tuning                     |
+| Небольшой датасет, few-shot или zero-shot            | Prompt Tuning / Soft Prompts                   |
+
+https://www.kaggle.com/code/purvasingh/text-generation-via-rnn-and-lstms-pytorch
+
+https://www.kaggle.com/code/neerajmohan/finetuning-large-language-models-using-qlora
+
+https://www.kaggle.com/code/thebrownviking20/intro-to-recurrent-neural-networks-lstm-gru?utm_source=chatgpt.com
+"""
+
+from transformers import BertTokenizerFast, BertForSequenceClassification, Trainer, TrainingArguments
+from torch.utils.data import Dataset
+import torch
+import evaluate
+import warnings
+
+# ... (previous code) ...
+
+
+# Training arguments
+training_args = TrainingArguments(
+    output_dir="./results",          # output directory
+    num_train_epochs=3,              # total number of training epochs
+    per_device_train_batch_size=8,  # batch size per device during training
+    per_device_eval_batch_size=64,   # batch size for evaluation
+    warmup_steps=500,                # number of warmup steps for learning rate scheduler
+    weight_decay=0.01,               # strength of weight decay
+    logging_dir='./logs',            # directory for storing logs
+    logging_steps=10,
+    evaluation_strategy="steps",
+    eval_steps=500,
+    save_steps=500,
+    save_total_limit=2
+)
+
+
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+    f1 = metric.compute(predictions=preds, references=labels, average="weighted")
+    return {
+        'f1': f1["f1"],
+    }
+
+# ... (rest of the code) ...

quic_start.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+"""quic_start.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1fJ_-FvN0auPakPWWqX6j6_H6i4k5OCY_
+"""
+
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = '3'
+
+"""# Установка и импорт"""
+
+!python3.10 -m pip install transformers datasets accelerate peft bitsandbytes sentencepiece --quiet
+
+import json
+import os
+from datasets import Dataset, load_from_disk
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    DataCollatorForLanguageModeling,
+    TrainingArguments,
+    Trainer
+)
+from peft import LoraConfig, get_peft_model, PeftModel
+import torch
+
+print("Torch version:", torch.__version__)
+print("Cuda available:", torch.cuda.is_available())
+
+# import json
+
+# data = [
+#     {"prompt": "Вопрос", "response": "Ответ"},
+#     {"prompt": "Что такое LLM?", "response": "LLM — это ..."},
+# ]
+
+# output_path = "data/train.jsonl"
+
+# with open(output_path, "w", encoding="utf-8") as f:
+#     for item in data:
+#         f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+"""# Загрузка данных"""
+
+train_path = "train.jsonl"
+val_path = None # "data/val.jsonl"  # можно оставить None
+
+def load_jsonl(path):
+    records = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            try:
+                records.append(json.loads(line))
+            except:
+                pass
+    return records
+
+train_data_raw = load_jsonl(train_path)
+# val_data_raw = load_jsonl(val_path) if os.path.exists(val_path) else None
+
+len(train_data_raw), train_data_raw[:2]
+
+"""# Создание датасета и токенизация
+
+| Модель                     | HF имя для загрузки                        | Параметры | Лицензия   | Сильные стороны                                         | Слабые стороны                   | Языки              |
+| -------------------------- | ------------------------------------------ | --------- | ---------- | ------------------------------------------------------- | -------------------------------- | ------------------ |
+| **Mistral-7B-Instruct**    | `mistralai/Mistral-7B-Instruct`            | 7.3B      | Apache 2.0 | Отличное качество, быстрый inference, сильный reasoning | multilingual средний             | EN + базовый multi |
+| **Mistral-7B**             | `mistralai/Mistral-7B-v0.1`                | 7.3B      | Apache 2.0 | Хороший pretrain baseline                               | хуже чем instruct в диалогах     | EN                 |
+| **Mixtral 8x7B Instruct**  | `mistralai/Mixtral-8x7B-Instruct-v0.1`     | MoE       | Apache 2.0 | Very strong reasoning/code                              | сложнее деплой                   | EN + multi         |
+| **LLaMA-2-7B-Chat**        | `meta-llama/Llama-2-7b-chat-hf`            | 7B        | Custom     | Баланс качества и удобства                              | уступает Mistral                 | EN                 |
+| **LLaMA-2-7B**             | `meta-llama/Llama-2-7b-hf`                 | 7B        | Custom     | Хороший pretrain                                        | слабый диалог без tuning         | EN                 |
+| **Falcon-7B-Instruct**     | `tiiuae/falcon-7b-instruct`                | 7B        | Apache 2.0 | Сильный английский диалог                               | хуже reasoning чем mistral       | EN                 |
+| **Falcon-7B**              | `tiiuae/falcon-7b`                         | 7B        | Apache 2.0 | Хороший генератор                                       | хуже чем instruct                | EN                 |
+| **MPT-7B-Instruct**        | `mosaicml/mpt-7b-instruct`                 | 7B        | Apache 2.0 | оптимизация для продакшн                                | уступает mistral                 | EN                 |
+| **MPT-7B**                 | `mosaicml/mpt-7b`                          | 7B        | Apache 2.0 | хорошая скорость                                        | average качество                 | EN                 |
+| **Baichuan2-7B-Chat**      | `baichuan-inc/Baichuan2-7B-Chat`           | 7B        | Permissive | сильный CN+EN, диалог                                   | ниже на EN reasoning             | CN, EN             |
+| **Baichuan2-7B-Base**      | `baichuan-inc/Baichuan2-7B-Base`           | 7B        | Permissive | большой CN корпус                                       | EN слабее                        | CN, EN             |
+| **Qwen-7B-Chat**           | `Qwen/Qwen-7B-Chat`                        | 7B        | Apache 2.0 | сильный CN/EN, мощный чат                               | нужно выбирать правильную версию | CN, EN             |
+| **Qwen-7B**                | `Qwen/Qwen-7B`                             | 7B        | Apache 2.0 | хорошая кодовая модель                                  | требует tuning для диалогов      | CN, EN             |
+| **InternLM-7B-Chat**       | `internlm/internlm-chat-7b`                | 7B        | Permissive | сильный CN-диалог                                       | EN средний                       | CN, EN             |
+| **InternLM-7B**            | `internlm/internlm-7b`                     | 7B        | Permissive | базовая CN модель                                       | слабее чем chat                  | CN                 |
+| **Pythia-6.9B**            | `EleutherAI/pythia-6.9b`                   | 6.9B      | Apache 2.0 | отлично для research                                    | не optimized для диалога         | EN                 |
+| **StableLM-3B-Instruct**   | `stabilityai/stablelm-3b-4e1t-instruct`    | 3B        | Apache 2.0 | лёгкая, быстрая                                         | меньшее качество                 | EN                 |
+| **StableLM-Base-Alpha 3B** | `stabilityai/stablelm-base-alpha-3b`       | 3B        | Apache 2.0 | маленькая, удобна для LoRA                              | слабее instruct                  | EN                 |
+| **StableCode 3B**          | `stabilityai/stablecode-instruct-alpha-3b` | 3B        | Apache 2.0 | хороша для code                                         | не для general dialogue          | EN                 |
+
+---
+
+```python
+import pandas as pd
+df = pd.read_csv("models.csv")
+
+def load_model_by_name(name, load_4bit=True):
+    row = df[df['name'] == name].iloc[0]
+    MODEL = row['hf_name']
+    print("Loading:", MODEL)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL, use_fast=True, trust_remote_code=True)
+
+    if load_4bit:
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL,
+            device_map="auto",
+            load_in_4bit=True,
+            trust_remote_code=True
+        )
+    else:
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL,
+            device_map="auto",
+            torch_dtype=torch.float16,
+            trust_remote_code=True
+        )
+    return tokenizer, model
+```
+"""
+
+MODEL = "Qwen/Qwen2.5-0.5B"
+MAX_LEN = 1024
+SEP = "\n\n### Ответ:\n\n"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL, use_fast=True)
+
+if tokenizer.pad_token is None:
+    tokenizer.add_special_tokens({"pad_token": "<|pad|>"})
+
+def make_dataset(records):
+    texts = [r["prompt"] + SEP + r["response"] for r in records]
+    ds = Dataset.from_dict({"text": texts})
+
+    def tokenize(batch):
+        out = tokenizer(
+            batch["text"],
+            truncation=True,
+            padding="max_length",
+            max_length=MAX_LEN
+        )
+        out["labels"] = out["input_ids"].copy()
+        return out
+
+    ds = ds.map(tokenize, batched=True, remove_columns=["text"])
+    return ds
+
+train_ds = make_dataset(train_data_raw)
+val_ds = None # make_dataset(val_data_raw) if val_data_raw else None
+
+train_ds
+
+"""# Загрузка модели и настройка LoRA"""
+
+USE_8BIT = False  # если есть большая модель — True
+
+print("Загружаем модель...")
+
+if USE_8BIT:
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL,
+        load_in_8bit=True,
+        device_map="auto",
+        torch_dtype=torch.float16,
+    )
+else:
+    model = AutoModelForCausalLM.from_pretrained(MODEL)
+
+model.resize_token_embeddings(len(tokenizer))
+
+lora_config = LoraConfig(
+    r=8,
+    lora_alpha=32,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # GPT2 → linear layers
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+
+model = get_peft_model(model, lora_config)
+
+print("LoRA слои установлены.")
+
+OUTPUT_DIR = "outputs/qwen_lora"
+
+data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+training_args = TrainingArguments(
+    output_dir=OUTPUT_DIR,
+    per_device_train_batch_size=2,
+    per_device_eval_batch_size=2,
+    gradient_accumulation_steps=8,
+    num_train_epochs=2,
+    learning_rate=2e-4,
+    warmup_ratio=0.03,
+    logging_steps=25,
+    save_steps=500,
+    evaluation_strategy="steps" if val_ds else "no",
+    eval_steps=500 if val_ds else None,
+    fp16=True,
+    save_total_limit=2,
+    gradient_checkpointing=True,
+    report_to="none",
+)
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_ds,
+    eval_dataset=val_ds,
+    data_collator=data_collator,
+)
+
+trainer
+
+trainer.train()
+model.save_pretrained(OUTPUT_DIR + "/peft_lora")
+print("LoRA веса сохранены.")
+
+def generate(prompt, max_new_tokens=150):
+    input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(model.device)
+
+    out = model.generate(
+        input_ids,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        temperature=0.8,
+        top_p=0.95,
+        top_k=50,
+        repetition_penalty=1.1,
+        pad_token_id=tokenizer.pad_token_id,
+        eos_token_id=tokenizer.eos_token_id,
+    )
+    return tokenizer.decode(out[0], skip_special_tokens=True)
+
+prompt = "Объясни простыми словами, что такое градиентный спуск."
+print(generate(prompt))
+
+"""## Перезагрузка модели с LoRA из сохранённого каталога
+
+(для отдельного запуска/после рестарта kernel)
+"""
+
+base_model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.float16, device_map="auto")
+base_tokenizer = AutoTokenizer.from_pretrained(MODEL)
+
+peft_model = PeftModel.from_pretrained(base_model, OUTPUT_DIR + "/peft_lora")
+
+def infer_lora(prompt):
+    input_ids = base_tokenizer(prompt, return_tensors="pt").input_ids.to(peft_model.device)
+    out = peft_model.generate(input_ids, max_new_tokens=100, do_sample=True)
+    return base_tokenizer.decode(out[0], skip_special_tokens=True)
+
+infer_lora("Расскажи, что такое нейронная сеть.")