Практическое использование моделей обучения с учителем

Трансфер обучения

Выводы:

1. Дообучение (fine-tuning) позволяет использовать общие модели для решения специфических задач.
2. Трансфер обучения (трансферное обучение) - это техника использования и дообучения предобученных моделей.
3. Позволяет существенно сэкономить ресурсы на обучение моделей.
4. Чаще всего применяется для нейросетей, но дообучать можно любые модели.
5. При трансфере обучения часть параметров модели может быть зафиксирована (freeze).
6. Позволяет использовать малые специфические датасеты.
7. Эффективность трансфера зависит от схожести задач.
8. Модель может быть обучена надругой задаче, припомощи обучения без учителя или другими произвольными техниками.

Векторизация данных

Выводы:

1. Для подачи данных на вход модели машинного обучения они должны быть представлены как вектор действительных чисел.
2. Векторизация - процесс преобразования данных из исходного формата в числовой вектор.
3. Существует много различных методов векторизации. Для разных задач могут подойти разные.
4. Методы векториации зависят от модальности входных данных.
5. Векторизация должна как можно более явно представлять значимую информацию из данных.
6. Эквивалентно извлечению признаков из данных.

Векторизация естественного текста

vectorizer = CountVectorizer()
bow = vectorizer.fit_transform(corpus)
vectorizer.vocabulary_
bow.toarray()

array([[0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1],
       [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0],
       [0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0]])

Выводы:

1. Есть много разных способов представить текст в виде чисел.
2. Мешок слов (bag of words) представляет документ в виде вектора слов.
3. Извлекает информацию о частотеслов в тексте. Позволяет сравнивать тематику текста.
4. Словарь составляется по обучающей выборке.
5. Для учета контекста часто используются N-граммы. Глубину контекста нужно подбирать.
6. На практике вместо слов используются токены.
7. Минусы - расход памяти, ортогональность токенов, нет учета схожести смысла слов.
8. TF-IDF используется для выделения специфических токенов документа, отличающихся от других документов корпуса.

Текстовые эмбеддинги

Выводы:

1. Текстовый эмбеддинг - это короткое и плотное векторное представление токенов, которое стремится учесть семантику.
2. Основываются на гипотезе о том, что семантически схожие слова употребляются в схожих контекстах.
3. Используют пространство латентных признаков. Размерность варьируется от 50 до 1000.
4. Модель Word2vec (2013) использует предобученную нейросеть, чтобы получать эмбеддинги с семантическими операциями суммы и разности.
5. Word2vec обучается на двух задачах частичного обучения с учителем. Используется для векторизации текстов.
6. Текстовые эмбеддинги позволяют существенно повысить эффективность моделей анализа естественных текстов.
7. Модель BERT (2018) более сложна и использует нейросеть сложной архитектуры. Контекстно-зависимая. Размерность - 768 или 1024.

Векторизация графических данных

Ансамблирование моделей

Выводы:

1. Ансамблевое обучение - техника обучения нескольких моделей на одной и той же задаче с целью повышения предсказательной эффективности.
2. Ансамбль - набор нескольких моделей машинного обучения и способ их комбинирования и обучения.
3. Ансамблирование - способ повысить эффективность за счет повышения вычислительной сложности.
4. Используется как в обучении с учителем, так и без него.
5. Ансамбль выступает как единая модель с входом и выходом. Техника обучения аналогичная.
6. Ансамбли также могут переобучаться и недообучаться.
7. Работает закон убывания отдачи в построении ансамбля.

Беггинг

clf1 = LogisticRegression(random_state=1)
clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
clf3 = GaussianNB()

eclf = VotingClassifier(
    estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)],
    voting='hard')

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

tree = DecisionTreeClassifier()
bagging_clf = BaggingClassifier(base_estimator=tree, 
                                n_estimators=1500, 
                                random_state=42)
bagging_clf.fit(X_train, y_train)

Выводы:

1. Беггинг (Bagging, bootstrap aggregating) - метод обучения нескольких моделей на подвыборках обучающей выборки.
2. Обучающая выборка разделяется на подмножества с повторениями. На каждом подмножестве обучается своя модель.
3. Комбинирование предикторов осуществляется усреднением либо голосованием.
4. Беггинг без ресемплинга - это простой голосующий ансамбль.
5. Голосование может быть жестким или мягким.
6. Существенно уменьшает вариативность моделей. ТАким образом борется с переобучением (ошибки усредняются).
7. Итоговая модель менее чувствительна к аномалиям и ошибкам в данных.
8. Обучение предикторов можно распараллелить.
9. Минусы - потеря интерпретируемости, вычислительная сложность.

Стекинг

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import StackingRegressor
final_estimator = GradientBoostingRegressor(
    n_estimators=25, subsample=0.5, 
    min_samples_leaf=25, max_features=1,
    random_state=42)
reg = StackingRegressor(
    estimators=estimators,
    final_estimator=final_estimator)

Выводы:

1. Стакинг (стекинг, stacking, Stacked generalization) - аналогично беггингу, но с добавлением метапредиктора (модель второго порядка).
2. Метапредиктор использует выходы ансамблевых предикторов как входные данные.
3. При стекинге используется разбиение обучающего набора на K фолдов, как при кросс-валидации.
4. Из-за комбинации преимуществ разных моделей способен существенно повысить точность.
5. Обучается дольше из-за органиченности параллелизации.
6. Склонен к переобучению из-за наличия модели второго порядка.

Бустинг

Выводы:

1. Идея бустинга - в последовательном анализе данных моделями из ансамбля.
2. Первая модель ансамбля обучается на всей выборке.
3. Следующая модель получает лишь те данные, на которых предыдущая модель ошиблась.
4. Последующие модели могут исправлять ошибки предыдущих.
5. Моделям присваиваются веса в зависимостиот их эффективности.
6. Может понижать смещение моделей.
7. В качестве предикторов обычно берутся простые модели с высоким смещением и низкой вариацией.
8. Из-за последовательной обработки данных, вычислительно сложен.
9. Чувствителен к выбросам и аномалиям.

Случайный лес

Выводы:

1. Случайные лес - это беггинг над набором деревьев решений.
2. Деревья решения имеют высокую вариацию, которую может снизить беггинг.
3. В случайном лесе обычно используется семплирование как по строкам, так и по столбцам.
4. Используется как для классификации, так и для регрессии.
5. Менее подвержены переобучению.
6. Чем больше количество дереьев, тем больше регуляризационный эффект.
7. Можно настраивать максимальное количество признаков для индивидуальных деревьев.

Градиентный бустинг

Выводы:

1. Адаптивный бустинг (AdaBoost) присваивает веса точкам обучающей выборки в зависимости от того, правильно ли они были распознаны первыми классификаторами.
2. Последующие классификаторы фокусируются на “сложных” случаях пропорционально весам.
3. Адаптивный бустинг зачастую применяется для задач бинарной классификации.
4. Граиентный бустинг (GBM) передает в последующие модели величину отклонения предыдущих моделей.
5. Градиентный бустинг использует деревья решений в качестве индивидуальных предикторов.
6. XGBoost - это параллелизуемая высокоэффективная реализация градиентного бустинга.
7. XGBoost может обрабатываеть большие объемы данных.
8. XGBoost склонен к переобучению, но использует регуляризацию.
9. XGBoost достаточно требователен к объему оперативной памяти.
10. Другие ивестные реалиации - LightGBM, CatBoost

CatBoost

Конвейеризация моделей

![](https://onnx.ai/sklearn-onnx/_images/blockdiag-0e2bbe287bfc020181cb7981832f234c906f12a6.png{: .align-center style=”width: 60%;”}

from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.decomposition import PCA
pipe = Pipeline([('reduce_dim', PCA()), 
                 ('clf', SVC())])
pipe.fit(iris.data, iris.target)

numeric_features = [0, 1, 2] # ["vA", "vB", "vC"]
categorical_features = [3, 4] # ["vcat", "vcat2"]

classifier = LogisticRegression(C=0.01, ...)

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder(sparse_output=True, handle_unknown='ignore')),
    ('tsvd', TruncatedSVD(n_components=1, algorithm='arpack', tol=1e-4))
])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])

model = Pipeline(steps=[
    ('precprocessor', preprocessor),
    ('classifier', classifier)
])

simple_imputer = SimpleImputer(strategy='median')
std_scaler = StandardScaler()

pipe_num = Pipeline([('imputer', simple_imputer), ('scaler', std_scaler)])

s_imputer = SimpleImputer(strategy='constant', fill_value='unknown')
ohe_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
pipe_cat = Pipeline([('imputer', s_imputer), ('encoder', ohe_encoder)])

col_transformer = ColumnTransformer([
    ('num_preproc', pipe_num, 
        [x for x in features.columns if features[x].dtype!='object']),
    ('cat_preproc', pipe_cat, 
        [x for x in features.columns if features[x].dtype=='object'])])

final_pipe = Pipeline([('preproc', col_transformer),
                       ('model', model)])

final_pipe.fit(features_train, target_train)
preds = final_pipe.predict(features_test)

from numpy.random import randint
from sklearn.base import BaseEstimator, TransformerMixin


class CustomTransformer(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        return self

    def transform(self, X, y=None):
        # Perform arbitary transformation
        X["random_int"] = randint(0, 10, X.shape[0])
        return X

import pandas as pd
from sklearn.pipeline import Pipeline


df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})

pipe = Pipeline(
    steps=[
        ("use_custom_transformer", CustomTransformer())
    ]
)
transformed_df = pipe.fit_transform(df)

Выводы:

1. Конвейер (pipeline) - это цепочка объектов sklearn, которая выступает единым объектом.
2. Конвейеры нужня для автоматизации обработки данных и машинного обучения и построения простого воспроизводимого кода.
3. Конвейер имеет единый интерфейс и может одной инструкцией применяться к разным данным.
4. В конвейер обычно объединяют операции предварительной обработки, преобразования и векторизации данных, предиктивную модель.
5. Модель обычно является последним этапом в конвейере.
6. Конвейеры удобны для тестирования гипотез.

Основные этапы проекта по машинному обучению