3_local_models_hf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![HuggingFace](images/hugging_face_logo.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QNhocsEsApmO"
   },
   "outputs": [],
   "source": [
    "# Установка Transformers\n",
    "! pip install transformers datasets\n",
    "# Чтобы установить из исходного кода вместо последнего релиза, закомментируйте команду выше и раскомментируйте следующую.\n",
    "# ! pip install git+https://github.com/huggingface/transformers.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nKpltsl2ApmQ"
   },
   "source": [
    "# Краткий обзор"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YjqjKUmcApmR"
   },
   "source": [
    "### Начните работу с 🤗 Transformers!\n",
    "\n",
    "Если вы хотите начать работать с Transformers, не важно, являетесь ли вы разработчиком или простым пользователем, этот краткий гид поможет вам разобраться и покажет, как:\n",
    "\n",
    "- Использовать [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) для создания выводов.\n",
    "- Загрузить предобученные модели и препроцессоры с помощью [AutoClass](https://huggingface.co/docs/transformers/main/en/./model_doc/auto).\n",
    "- Быстро обучить модель, используя PyTorch или TensorFlow.\n",
    "\n",
    "Если вы новичок, мы настоятельно рекомендуем ознакомиться с нашими руководствами или [курсом](https://huggingface.co/course/chapter1/1), чтобы лучше понять представленные концепции.\n",
    "\n",
    "#### Подготовка к работе\n",
    "\n",
    "Перед началом работы убедитесь, что у вас установлены все необходимые библиотеки:\n",
    "\n",
    "```bash\n",
    "!pip install transformers datasets\n",
    "```\n",
    "\n",
    "Кроме того, вам потребуется установить предпочитаемую библиотеку для машинного обучения:\n",
    "\n",
    "Для работы с **PyTorch**:\n",
    "\n",
    "```bash\n",
    "pip install torch\n",
    "```\n",
    "\n",
    "Или, если предпочитаете **TensorFlow**:\n",
    "\n",
    "```bash\n",
    "pip install tensorflow\n",
    "```\n",
    "\n",
    "Теперь вы готовы начать свое приключение с Hugging Face Transformers! 🌟"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pOIg0ISWApmS"
   },
   "source": [
    "## Конвейер (Pipeline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hAIR7bgwApmT"
   },
   "source": [
    "The function [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) — это простейший и наивысший по скорости способ применения предварительно обученной модели для выполнения выводов. Благодаря [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) \"из коробки\", вы можете с легкостью совершать множество задач в различных модальностях. Пример задач представлен в таблице ниже:\n",
    "\n",
    "<Hint>\n",
    "\n",
    "Чтобы получить полный перечень доступных задач, ознакомьтесь с [API функциями pipeline](https://huggingface.co/docs/transformers/main/en/./main_classes/pipelines).\n",
    "\n",
    "</Hint>\n",
    "\n",
    "| **Задача**                          | **Описание**                                                                                                          | **Модальность**       | **Идентификатор pipeline**                      |\n",
    "|-------------------------------------|----------------------------------------------------------------------------------------------------------------------|-----------------------|------------------------------------------------|\n",
    "| Классификация текста                | Присвоение метки для заданной последовательности текста                                                              | Обработка текста      | pipeline(task=“sentiment-analysis”)             |\n",
    "| Генерация текста                    | Создание текста на основе введенной начальной фразы                                                                  | Обработка текста      | pipeline(task=“text-generation”)                |\n",
    "| Резюмирование                       | Составление резюме или краткого изложения текста или документа                                                        | Обработка текста      | pipeline(task=“summarization”)                  |\n",
    "| Классификация изображений           | Присвоение метки изображению                                                                                         | Компьютерное зрение   | pipeline(task=“image-classification”)          |\n",
    "| Сегментация изображений             | Присвоение меток каждому пикселю изображения (поддерживает семантическую, паноптическую и инстанс сегментацию)        | Компьютерное зрение   | pipeline(task=“image-segmentation”)            |\n",
    "| Обнаружение объектов                | Прогнозирование границ (bounding boxes) и классов объектов на изображении                                            | Компьютерное зрение   | pipeline(task=“object-detection”)              |\n",
    "| Классификация аудио                 | Присвоение метки аудиоданным                                                                                          | Аудио                 | pipeline(task=“audio-classification”)          |\n",
    "| Автоматическое распознавание речи   | Преобразование речи в текст                                                                                          | Аудио                 | pipeline(task=“automatic-speech-recognition”)  |\n",
    "| Визуальные вопросы и ответы         | Ответы на вопросы об изображении, предоставляя изображение и вопрос                                                  | Мультимодальный       | pipeline(task=“vqa”)                           |\n",
    "| Вопросы и ответы по документу       | Ответы на вопросы о документе, предоставляя изображение и вопрос                                                     | Мультимодальный       | pipeline(task=\"document-question-answering\")   |\n",
    "| Описания изображений                | Генерация описания для данного изображения                                                                           | Мультимодальный       | pipeline(task=\"image-to-text\")                  |\n",
    "\n",
    "Чтобы приступить, создайте экземпляр [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) и укажите задачу, которую вы хотите выполнить. В этом руководстве вы можете использовать [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) для анализа тональности как пример."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-lYoc1YvApmT"
   },
   "outputs": [],
   "source": [
    "from transformers import pipeline\n",
    "\n",
    "classifier = pipeline(\"sentiment-analysis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L2spyZOeApmU"
   },
   "source": [
    "Функция [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) загружает и кэширует стандартную [предобученную модель](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english) и токенизатор для анализа настроений. Теперь вы можете использовать `classifier` для анализа ваших целевых текстов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zInn37qmApmV",
    "outputId": "e4363c43-79bb-4d48-e0a4-193129e5e018"
   },
   "outputs": [],
   "source": [
    "classifier(\"We are very happy to show you the 🤗 Transformers library.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HuPX1Wz2ApmV"
   },
   "source": [
    "Если у вас несколько входных данных, передайте их в виде списка в функцию [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline), чтобы получить список словарей в ответ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-AEnhUq-ApmW",
    "outputId": "aef3b8ff-f921-4db9-b08d-f281891bb1b4"
   },
   "outputs": [],
   "source": [
    "results = classifier([\"We are very happy to show you the 🤗 Transformers library.\", \"We hope you don't hate it.\"])\n",
    "for result in results:\n",
    "    print(f\"label: {result['label']}, with score: {round(result['score'], 4)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s6g02yxbApmW"
   },
   "source": [
    "Функция [`pipeline()`](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) также может выполнять итерации по всему набору данных для любой задачи, которую вы выберете. В этом примере давайте выберем автоматическое распознавание речи в качестве нашей задачи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nvPCbWvdApmW"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from transformers import pipeline\n",
    "\n",
    "speech_recognizer = pipeline(\"automatic-speech-recognition\", model=\"facebook/wav2vec2-base-960h\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-pkdSZ45ApmW"
   },
   "source": [
    "Чтобы начать работу с аудио датасетом, можно следовать [Быстрому старту](https://huggingface.co/docs/datasets/quickstart#audio) от 🤗 Datasets. Вот как можно загрузить датасет [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14):\n",
    "\n",
    "```python\n",
    "from datasets import load_dataset\n",
    "\n",
    "# Загрузка датасета MInDS-14\n",
    "dataset = load_dataset(\"PolyAI/minds14\")\n",
    "```\n",
    "\n",
    "Эта простая команда позволяет вам загружать и использовать датасет MInDS-14 для итерации и анализа. Убедитесь, что у вас установлены необходимые библиотеки и ваше окружение готово к работе с аудио данными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9C3SLqVOApmW"
   },
   "outputs": [],
   "source": [
    "from datasets import load_dataset, Audio\n",
    "\n",
    "dataset = load_dataset(\"PolyAI/minds14\", name=\"en-US\", split=\"train\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8g5pSDU5ApmX"
   },
   "source": [
    "Вам необходимо убедиться, что частота дискретизации вашего набора данных совпадает с частотой, на которой была обучена модель [`facebook/wav2vec2-base-960h`](https://huggingface.co/facebook/wav2vec2-base-960h):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IEphyJFLApmX"
   },
   "outputs": [],
   "source": [
    "dataset = dataset.cast_column(\"audio\", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VQmPE3L2ApmX"
   },
   "source": [
    "Аудиофайлы автоматически загружаются и пересэмплируются при обращении к столбцу `\"audio\"`. Извлеките массивы сырых волновых сигналов из первых 4 образцов и передайте их как список в конвейер:\n",
    "\n",
    "```python\n",
    "# Пример кода для выполнения этой задачи\n",
    "waveform_arrays = []\n",
    "for i in range(4):\n",
    "    waveform_array = dataset[i][\"audio\"][\"array\"]  # Извлекаем массив волны\n",
    "    waveform_arrays.append(waveform_array)\n",
    "\n",
    "# Передаем список массивов в конвейер\n",
    "pipeline_output = some_pipeline(waveform_arrays)\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F3vCpgz6ApmX",
    "outputId": "200d9d1c-bd8f-46cf-ad6e-59042a117f92"
   },
   "outputs": [],
   "source": [
    "result = speech_recognizer(dataset[:4][\"audio\"])\n",
    "print([d[\"text\"] for d in result])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9xLFYJhDApmX"
   },
   "source": [
    "Для работы с большими наборами данных, где входные данные значительны (например, в задачах обработки речи или изображений), лучше использовать генератор вместо списка, чтобы не загружать все данные в память одновременно. Подробнее об этом можно узнать в [документации к API pipeline](https://huggingface.co/docs/transformers/main/en/./main_classes/pipelines)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ej9zt6_2ApmX"
   },
   "source": [
    "### Использование другой модели и токенизатора в пайплайне\n",
    "\n",
    "Если вы хотите использовать другую модель и токенизатор в вашем пайплайне, то, к счастью, это можно сделать достаточно просто. В пакете `transformers` от Hugging Face процесс сводится к нескольким шагам:\n",
    "\n",
    "```python\n",
    "from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer\n",
    "\n",
    "# Загрузка модели и токенизатора\n",
    "model = AutoModelForSequenceClassification.from_pretrained('my-custom-model')\n",
    "tokenizer = AutoTokenizer.from_pretrained('my-custom-model')\n",
    "\n",
    "# Создание пайплайна со своей моделью и токенизатором\n",
    "custom_pipeline = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)\n",
    "\n",
    "# Тестирование нового пайплайна\n",
    "result = custom_pipeline(\"Ваш текст здесь!\")\n",
    "print(result)\n",
    "```\n",
    "\n",
    "### Пояснения\n",
    "\n",
    "- **AutoModelForSequenceClassification**: Этот класс используется для загрузки предобученной модели, способной выполнять задачи классификации последовательностей.\n",
    "  \n",
    "- **AutoTokenizer**: Он отвечает за обработку текстов, превращая их в формат, который может \"понять\" модель.\n",
    "\n",
    "- **pipeline**: Позволяет быстро создавать и использовать различные комбинации моделей и токенизаторов для задач NLP.\n",
    "\n",
    "### Советы\n",
    "\n",
    "- Убедитесь, что модель и токенизатор, которые вы используете, совместимы друг с другом.\n",
    "- Ознакомьтесь с документацией [Hugging Face](https://huggingface.co/transformers/) для получения более подробной информации о доступных моделях и токенизаторах.\n",
    "- Если модель и токенизатор доступны на платформе Hugging Face, вы можете использовать их идентификаторы для прямой загрузки.\n",
    "\n",
    "OpenAI tokenizer tool - https://platform.openai.com/tokenizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HeVxj5uWApmY"
   },
   "source": [
    "Функция [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) может работать с любой моделью из [Hub](https://huggingface.co/models), что облегчает адаптацию [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline) для различных задач. Например, если вам нужна модель для обработки текста на французском языке, используйте теги на Hub, чтобы отфильтровать подходящую модель. В результате фильтрации можно увидеть, что многоязычная модель [BERT](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment), адаптированная для анализа сентиментов, отлично подойдет для работы с текстом на французском языке:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jJ09WjqhApmY"
   },
   "outputs": [],
   "source": [
    "model_name = \"nlptown/bert-base-multilingual-uncased-sentiment\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HVX50azNApmY"
   },
   "source": [
    "Для использования предварительно обученной модели и её связанного токенизатора с помощью классов [AutoModelForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForSequenceClassification) и [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer) выполните следующий код:\n",
    "\n",
    "```python\n",
    "from transformers import AutoModelForSequenceClassification, AutoTokenizer\n",
    "\n",
    "# Укажите путь или имя модели\n",
    "model_name = \"имя_предварительно_обученной_модели\"\n",
    "\n",
    "# Загрузка модели\n",
    "model = AutoModelForSequenceClassification.from_pretrained(model_name)\n",
    "\n",
    "# Загрузка токенизатора\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "```\n",
    "\n",
    "Эти классы `AutoClass` позволяют автоматически определять правильную конфигурацию, связанную с указанной моделью, делая процесс загрузки более простым и универсальным. Дополнительную информацию об `AutoClass` вы можете узнать в следующем разделе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "H6DzpIDWApmY"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n",
    "\n",
    "model = AutoModelForSequenceClassification.from_pretrained(model_name)\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fk9_fxcEApmY"
   },
   "source": [
    "Используйте [TFAutoModelForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.TFAutoModelForSequenceClassification) и [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer), чтобы загрузить предобученную модель и её соответствующий токенайзер (о `TFAutoClass` будет больше информации в следующем разделе):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9n0zWJhtApmY"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer, TFAutoModelForSequenceClassification\n",
    "\n",
    "model = TFAutoModelForSequenceClassification.from_pretrained(model_name)\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Le3laUIIApmY"
   },
   "source": [
    "Укажите модель и токенизатор в функции [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline), и теперь вы можете применять `classifier` к тексту на французском языке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "advnZ0wPApmZ",
    "outputId": "6396d18a-acff-45bc-e1b3-979b7e54fb96"
   },
   "outputs": [],
   "source": [
    "classifier = pipeline(\"sentiment-analysis\", model=model, tokenizer=tokenizer)\n",
    "classifier(\"Nous sommes très heureux de vous présenter la bibliothèque 🤗 Transformers.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FO-70sdPApmZ"
   },
   "source": [
    "Если вы не можете найти подходящую модель для своего случая, вам потребуется дообучить предварительно обученную модель на ваших данных. Ознакомьтесь с нашим [руководством по дообучению](https://huggingface.co/docs/transformers/main/en/./training), чтобы узнать, как это сделать. И наконец, после того как вы дообучите свою модель, пожалуйста, подумайте о том, чтобы [поделиться](https://huggingface.co/docs/transformers/main/en/./model_sharing) моделью с сообществом на Hub, чтобы сделать машинное обучение доступным для всех! 🤗"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MDrSyQJsApmZ"
   },
   "source": [
    "## АвтоКласс"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SHbTwd2cApma"
   },
   "source": [
    "Под капотом, классы [AutoModelForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForSequenceClassification) и [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer) работают вместе, чтобы запустить [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline), который вы использовали выше. [AutoClass](https://huggingface.co/docs/transformers/main/en/./model_doc/auto) представляет собой сокращение, которое автоматически получает архитектуру предобученной модели по её названию или пути. Вам нужно лишь выбрать соответствующий `AutoClass` для вашей задачи и подходящий класс для предварительной обработки данных.\n",
    "\n",
    "Вернёмся к примеру из предыдущего раздела и посмотрим, как можно использовать `AutoClass`, чтобы воспроизвести результаты работы [pipeline()](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.pipeline)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-hVWaKvBApma"
   },
   "source": [
    "### AutoTokenizer\n",
    "\n",
    "`AutoTokenizer` — это компонент библиотеки 🤗 Transformers, который умеет автоматически формировать подходящий токенизатор, исходя из указанной модели. Он позволяет значительно упростить процесс настройки и использования токенизаторов для различных задач.\n",
    "\n",
    "С помощью `AutoTokenizer`, вы можете легко получить нужный токенизатор без необходимости указывать конкретный класс токенизатора, который соответствует выбранной модели. Достаточно только знать имя модели, и `AutoTokenizer` сделает за вас всю остальную работу.\n",
    "\n",
    "#### Пример использования\n",
    "\n",
    "```python\n",
    "from transformers import AutoTokenizer\n",
    "\n",
    "# Инициализация токенизатора для определенной модели\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-uncased\")\n",
    "\n",
    "# Токенизация примерного текста\n",
    "tokens = tokenizer.tokenize(\"Hello, how are you?\")\n",
    "\n",
    "print(tokens)\n",
    "```\n",
    "\n",
    "#### Преимущества\n",
    "\n",
    "- **Универсальность**: поддерживает широкий диапазон моделей и заданий.\n",
    "- **Простота**: минимальные усилия для выбора и настройки правильного токенизатора.\n",
    "- **Гибкость**: легко адаптируется под различные языковые модели и их версии.\n",
    "\n",
    "### Заключение\n",
    "\n",
    "Использование `AutoTokenizer` значительно ускоряет процесс подготовки данных для языковых моделей и дает возможность сосредоточиться на выполнении самой задачи, не отвлекаясь на технические детали токенизации."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L75OYf2BApma"
   },
   "source": [
    "Токенизатор отвечает за предварительную обработку текста, преобразуя его в массив чисел, которые будут использоваться в качестве входных данных для модели. Существует множество правил, регулирующих процесс токенизации, включая способы деления слова и уровень, на котором следует разделять слова (узнать больше о токенизации можно в [кратком обзоре токенизатора](https://huggingface.co/docs/transformers/main/en/./tokenizer_summary)). Самое важное, что нужно помнить, это то, что необходимо создавать экземпляр токенизатора с тем же именем модели, чтобы обеспечить использование тех же правил токенизации, с которыми модель была предварительно обучена.\n",
    "\n",
    "Загрузите токенизатор с помощью [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "neIbBhgSApma"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer\n",
    "\n",
    "model_name = \"nlptown/bert-base-multilingual-uncased-sentiment\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cZGHVGSbApma"
   },
   "source": [
    "Пропустите ваш текст через токенизатор:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ly6WGNM2Apmc",
    "outputId": "5594bcc9-9a9d-4cac-c104-e602567e5155"
   },
   "outputs": [],
   "source": [
    "encoding = tokenizer(\"We are very happy to show you the 🤗 Transformers library.\")\n",
    "print(encoding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f7guhzf2Apmc"
   },
   "source": [
    "Токенизатор возвращает словарь, содержащий:\n",
    "\n",
    " * [input_ids](https://huggingface.co/docs/transformers/main/en/./glossary#input-ids): числовые представления ваших токенов.\n",
    " * [attention_mask](https://huggingface.co/docs/transformers/main/en/.glossary#attention-mask): показывает, какие токены следует учитывать.\n",
    "\n",
    "Токенизатор также может принимать список входных данных, а также дополнить и обрезать текст для возврата пакета с одинаковой длиной:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7vMjrDiwApmg"
   },
   "outputs": [],
   "source": [
    "pt_batch = tokenizer(\n",
    "    [\"We are very happy to show you the 🤗 Transformers library.\", \"We hope you don't hate it.\"],\n",
    "    padding=True,\n",
    "    truncation=True,\n",
    "    max_length=512,\n",
    "    return_tensors=\"pt\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EnJW_aCjApmh"
   },
   "outputs": [],
   "source": [
    "tf_batch = tokenizer(\n",
    "    [\"We are very happy to show you the 🤗 Transformers library.\", \"We hope you don't hate it.\"],\n",
    "    padding=True,\n",
    "    truncation=True,\n",
    "    max_length=512,\n",
    "    return_tensors=\"tf\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U8v69RiXApmh"
   },
   "source": [
    "<Tip>\n",
    "\n",
    " Ознакомьтесь с [руководством по предварительной обработке](https://huggingface.co/docs/transformers/main/en/./preprocessing), чтобы узнать больше о токенизации и использовании [AutoImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoImageProcessor), [AutoFeatureExtractor](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoFeatureExtractor) и [AutoProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoProcessor) для предварительной обработки изображений, аудио и мультимодальных данных.\n",
    "\n",
    "</Tip>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uhQ850_cApmh"
   },
   "source": [
    "### АвтоМодель\n",
    "\n",
    "<details>\n",
    "<summary>Нажмите, чтобы раскрыть информацию</summary>\n",
    "\n",
    "AutoModel — это удобный инструмент в библиотеке Hugging Face, который позволяет легко загружать предобученные модели. Он автоматически определяет, какой тип модели требуется, и загружает соответствующее хранилище и конфигурацию. Это значительно упрощает работу, поскольку вам не нужно специально указывать тип модели, которую вы хотите использовать.\n",
    "\n",
    "Чтобы начать использовать AutoModel, требуется лишь несколько строк кода. Например:\n",
    "\n",
    "```python\n",
    "from transformers import AutoModel, AutoTokenizer\n",
    "\n",
    "model_name = \"bert-base-uncased\"\n",
    "model = AutoModel.from_pretrained(model_name)\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "\n",
    "# Теперь вы можете использовать модель и токенизатор\n",
    "```\n",
    "\n",
    "Эта пара строк скачает и инициализирует BERT-модель из хранилища Hugging Face, которую затем можно использовать для различных NLP задач, таких как классификация текста, создание ответов и другие.\n",
    "\n",
    "Для получения дополнительной информации и примеров использования посетите [Hugging Face Transformers](https://huggingface.co/transformers/).\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XCpppjFMApmh"
   },
   "source": [
    "🤗 Библиотека Transformers предоставляет простой и единообразный способ загрузки предобученных моделей. Это означает, что вы можете загружать [AutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModel) так же, как и [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer). Единственное отличие заключается в выборе правильной [AutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModel) для конкретной задачи. Например, для классификации текста (или последовательностей) следует загружать [AutoModelForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForSequenceClassification):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dp1rLlHQApmh"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoModelForSequenceClassification\n",
    "\n",
    "model_name = \"nlptown/bert-base-multilingual-uncased-sentiment\"\n",
    "pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lPvAmUwXApmh"
   },
   "source": [
    "<Tip>\n",
    "\n",
    "Изучите [краткий обзор задач](https://huggingface.co/docs/transformers/main/en/./task_summary), чтобы узнать, какие задачи поддерживает класс [AutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModel).\n",
    "\n",
    "</Tip>\n",
    "\n",
    "Теперь передайте предварительно обработанный пакет входных данных непосредственно модели. Для этого просто распакуйте словарь, добавив `**`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dl1WQxw5Apmh"
   },
   "outputs": [],
   "source": [
    "pt_outputs = pt_model(**pt_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "unRgMPcZApmh"
   },
   "source": [
    "Модель выдает итоговые активации в атрибуте `logits`. Чтобы получить вероятности, примените софтмакс-функцию к `logits`:\n",
    "\n",
    "```python\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Пример, как использовать softmax для получения вероятностей\n",
    "probabilities = F.softmax(logits, dim=-1)\n",
    "```\n",
    "\n",
    "Здесь `dim=-1` указывает на то, что функция будет применена вдоль последнего измерения, преобразуя логиты в вероятности."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1xn5uP26Apmi",
    "outputId": "c14dff38-7a71-402e-cc2a-d4654630dac4"
   },
   "outputs": [],
   "source": [
    "from torch import nn\n",
    "\n",
    "pt_predictions = nn.functional.softmax(pt_outputs.logits, dim=-1)\n",
    "print(pt_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qXsftP0eApmi"
   },
   "source": [
    "🤗 Transformers предоставляет простой и унифицированный способ загрузки заранее обученных экземпляров. Это означает, что вы можете загрузить [TFAutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.TFAutoModel) так же, как вы бы загрузили [AutoTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer). Единственное отличие – это выбор подходящей [TFAutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.TFAutoModel) для конкретной задачи. Для текстовой (или последовательностной) классификации следует загрузить [TFAutoModelForSequenceClassification](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.TFAutoModelForSequenceClassification):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0u669PFnApmi"
   },
   "outputs": [],
   "source": [
    "from transformers import TFAutoModelForSequenceClassification\n",
    "\n",
    "model_name = \"nlptown/bert-base-multilingual-uncased-sentiment\"\n",
    "tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gYv2au41Apmi"
   },
   "source": [
    "<Tip>\n",
    "\n",
    "Посмотрите [сводку задач](https://huggingface.co/docs/transformers/main/en/./task_summary), чтобы узнать о задачах, поддерживаемых классом [AutoModel](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModel).\n",
    "\n",
    "</Tip>\n",
    "\n",
    "Теперь передайте предварительно обработанный пакет входных данных непосредственно в модель, передавая ключи словаря напрямую к тензорам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AUXM4d98Apmi"
   },
   "outputs": [],
   "source": [
    "tf_outputs = tf_model(tf_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RtRl-V4UApmj"
   },
   "source": [
    "Модель выдает окончательные активации в атрибуте `logits`. Чтобы получить вероятности, примените функцию softmax к `logits`:\n",
    "\n",
    "```python\n",
    "import torch\n",
    "\n",
    "# Предположим, что значения logits уже известны\n",
    "logits = torch.tensor([2.0, 1.0, 0.1])\n",
    "\n",
    "# Применяем softmax, чтобы получить вероятности\n",
    "probabilities = torch.nn.functional.softmax(logits, dim=0)\n",
    "\n",
    "print(probabilities)\n",
    "```\n",
    "\n",
    "Данный код применяет функцию softmax к элементам вектора `logits`, переводя их в вероятности, которые суммируются до 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r7ObVhuQApmj"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1)\n",
    "tf_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IaXAeJNQApmj"
   },
   "source": [
    "<Tip>\n",
    "\n",
    "Все модели 🤗 Transformers (как на PyTorch, так и на TensorFlow) выдают тензоры *до* применения заключительной функции активации (например, softmax), поскольку итоговая функция активации часто объединяется с функцией потерь. Выходные данные моделей представлены в виде специальных dataclass-структур, поэтому их атрибуты поддерживают автодополнение в среде разработки. Эти выходные данные ведут себя как кортежи или словари (их можно индексировать, используя целое число, срез или строку), при этом атрибуты со значением None игнорируются.\n",
    "\n",
    "</Tip>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nUERc30fApmj"
   },
   "source": [
    "### Сохранение модели\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZquZTNWwApmj"
   },
   "source": [
    "Как только ваша модель настроена, вы можете сохранить ее вместе с токенизатором, используя метод [PreTrainedModel.save_pretrained()](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.save_pretrained):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8BrWPXhmApmj"
   },
   "outputs": [],
   "source": [
    "pt_save_directory = \"./pt_save_pretrained\"\n",
    "tokenizer.save_pretrained(pt_save_directory)\n",
    "pt_model.save_pretrained(pt_save_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0bdUgOD2Apmk"
   },
   "source": [
    "Когда будете готовы вновь использовать модель, перезагрузите её с помощью метода [PreTrainedModel.from_pretrained()](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SLtNYRQbApmk"
   },
   "outputs": [],
   "source": [
    "pt_model = AutoModelForSequenceClassification.from_pretrained(\"./pt_save_pretrained\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ty-HqtNaApmk"
   },
   "source": [
    "Когда ваша модель настроена по вашему запросу, вы можете сохранить её вместе с токенизатором, используя [TFPreTrainedModel.save_pretrained()](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel.save_pretrained):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fV_pmwqxApmk"
   },
   "outputs": [],
   "source": [
    "tf_save_directory = \"./tf_save_pretrained\"\n",
    "tokenizer.save_pretrained(tf_save_directory)\n",
    "tf_model.save_pretrained(tf_save_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z9VE0it8Apmk"
   },
   "source": [
    "Когда вы будете готовы использовать модель снова, загрузите её с помощью метода [TFPreTrainedModel.from_pretrained()](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "efibEoB8Apmk"
   },
   "outputs": [],
   "source": [
    "tf_model = TFAutoModelForSequenceClassification.from_pretrained(\"./tf_save_pretrained\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y0u7u_q8Apmk"
   },
   "source": [
    "Одной из особенно полезных возможностей 🤗 Transformers является способность сохранять модель и загружать её как модель для PyTorch или TensorFlow. Параметр `from_pt` или `from_tf` позволяет преобразовать модель из одной фреймворка в другой:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GSKdoNlDApml"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoModel\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(tf_save_directory)\n",
    "pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6VwyCPUQApml"
   },
   "outputs": [],
   "source": [
    "from transformers import TFAutoModel\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)\n",
    "tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0AQs3UnwApml"
   },
   "source": [
    "## Создание индивидуальных моделей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iaILOvQ7Apml"
   },
   "source": [
    "Вы можете изменить класс конфигурации модели, чтобы задать, каким образом она будет построена. Конфигурация определяет атрибуты модели, такие как количество скрытых слоев или голов внимания. Когда вы инициализируете модель из класса пользовательской конфигурации, вы начинаете с нуля. Атрибуты модели инициализируются случайным образом, и вам потребуется обучить модель, прежде чем она начнет выдавать осмысленные результаты.\n",
    "\n",
    "Начните с импорта [AutoConfig](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoConfig), затем загрузите предварительно обученную модель, которую вы хотите изменить. В методе [AutoConfig.from_pretrained()](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoConfig.from_pretrained) можно указать атрибут, который вы хотите изменить, например, количество голов внимания:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OcWbhrUVApml"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoConfig\n",
    "\n",
    "my_config = AutoConfig.from_pretrained(\"distilbert-base-uncased\", n_heads=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WLoIyZMuApml"
   },
   "source": [
    "Чтобы создать модель из вашей индивидуальной конфигурации с использованием метода [AutoModel.from_config()](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.FlaxAutoModelForVision2Seq.from_config), выполните следующие шаги:\n",
    "\n",
    "```python\n",
    "from transformers import AutoConfig, AutoModel\n",
    "\n",
    "# Шаг 1: Создайте свою конфигурацию модели\n",
    "config = AutoConfig.from_pretrained(\"ваш_набор_конфигурации\")\n",
    "\n",
    "# Шаг 2: Создайте модель, используя вашу конфигурацию\n",
    "model = AutoModel.from_config(config)\n",
    "\n",
    "# Теперь у вас есть модель, построенная на основе вашей уникальной конфигурации\n",
    "```\n",
    "\n",
    "Этот подход позволяет вам использовать заранее определённые параметры конфигурации, чтобы гибко создавать модели, учитывая ваши конкретные потребности и задачи. Если у вас есть заранее определённые настройки, которые вы хотите включить в модель, это отличный способ сделать это."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "euZ3M2LqApml"
   },
   "outputs": [],
   "source": [
    "from transformers import AutoModel\n",
    "\n",
    "my_model = AutoModel.from_config(my_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_UV6_KGuApmm"
   },
   "source": [
    "Чтобы создать модель на основе вашей пользовательской конфигурации, используя метод `TFAutoModel.from_config()`, следуйте приведенной ниже структуре:\n",
    "\n",
    "```python\n",
    "from transformers import TFAutoModel\n",
    "\n",
    "# Предположим, у вас есть конфигурация, загруженная в объект config\n",
    "config = ...\n",
    "\n",
    "# Создание модели из конфигурации\n",
    "model = TFAutoModel.from_config(config)\n",
    "\n",
    "# Теперь вы можете использовать вашу модель для различных задач\n",
    "```\n",
    "\n",
    "В данном примере мы предполагаем, что у вас уже существует объект конфигурации `config`, который будет использоваться для создания модели. Метод `from_config()` помогает инициализировать вашу модель на основе этой конфигурации. Не забывайте, что `TFAutoModel` относится к версии с поддержкой TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GGhnNo4LApmm"
   },
   "outputs": [],
   "source": [
    "from transformers import TFAutoModel\n",
    "\n",
    "my_model = TFAutoModel.from_config(my_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ofp_uo1nApmm"
   },
   "source": [
    "Ознакомьтесь с руководством [Создание пользовательской архитектуры](https://huggingface.co/docs/transformers/main/en/./create_a_model) для получения дополнительной информации о создании пользовательских конфигураций."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HGtphJrvApmm"
   },
   "source": [
    "## Trainer - оптимизированный цикл обучения PyTorch\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kPcGR6WUApmn"
   },
   "source": [
    "Все модели представляют собой стандартный [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), поэтому их можно использовать в любом типичном цикле обучения. Хотя вы можете написать собственный цикл обучения, библиотека 🤗 Transformers предлагает класс [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) для PyTorch, который включает базовую логику обучения и добавляет дополнительную функциональность, такую как распределенное обучение, смешанная точность и многое другое.\n",
    "\n",
    "В зависимости от вашей задачи, вам обычно нужно передать следующие параметры в [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer):\n",
    "\n",
    "1. [PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel) или [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module):\n",
    "\n",
    "    ```python\n",
    "    >>> from transformers import AutoModelForSequenceClassification\n",
    "\n",
    "    >>> model = AutoModelForSequenceClassification.from_pretrained(\"distilbert-base-uncased\")\n",
    "    ```\n",
    "\n",
    "2. [TrainingArguments](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments), содержащие гиперпараметры модели, которые можно изменить, такие как скорость обучения, размер пакета и количество эпох для обучения. Если вы не укажете параметры, будут использоваться значения по умолчанию:\n",
    "\n",
    "    ```python\n",
    "    >>> from transformers import TrainingArguments\n",
    "\n",
    "    >>> training_args = TrainingArguments(\n",
    "    ...     output_dir=\"path/to/save/folder/\",\n",
    "    ...     learning_rate=2e-5,\n",
    "    ...     per_device_train_batch_size=8,\n",
    "    ...     per_device_eval_batch_size=8,\n",
    "    ...     num_train_epochs=2,\n",
    "    ... )\n",
    "    ```\n",
    "\n",
    "3. Класс для предобработки данных, например, токенизатор, процессор изображений, извлекатель признаков или процессор:\n",
    "\n",
    "    ```python\n",
    "    >>> from transformers import AutoTokenizer\n",
    "\n",
    "    >>> tokenizer = AutoTokenizer.from_pretrained(\"distilbert-base-uncased\")\n",
    "    ```\n",
    "\n",
    "4. Загрузите датасет:\n",
    "\n",
    "    ```python\n",
    "    >>> from datasets import load_dataset\n",
    "\n",
    "    >>> dataset = load_dataset(\"rotten_tomatoes\")  # doctest: +IGNORE_RESULT\n",
    "    ```\n",
    "\n",
    "5. Создайте функцию для токенизации датасета:\n",
    "\n",
    "    ```python\n",
    "    >>> def tokenize_dataset(dataset):\n",
    "    ...     return tokenizer(dataset[\"text\"])\n",
    "    ```\n",
    "\n",
    "    Затем примените её ко всему датасету с помощью [map](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset.map):\n",
    "\n",
    "    ```python\n",
    "    >>> dataset = dataset.map(tokenize_dataset, batched=True)\n",
    "    ```\n",
    "\n",
    "6. [DataCollatorWithPadding](https://huggingface.co/docs/transformers/main/en/main_classes/data_collator#transformers.DataCollatorWithPadding) для создания пакета примеров из вашего датасета:\n",
    "\n",
    "    ```python\n",
    "    >>> from transformers import DataCollatorWithPadding\n",
    "\n",
    "    >>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)\n",
    "    ```\n",
    "\n",
    "Теперь соберите все эти классы в [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Am1Hnt8cApmn"
   },
   "outputs": [],
   "source": [
    "from transformers import Trainer\n",
    "\n",
    "trainer = Trainer(\n",
    "    model=model,\n",
    "    args=training_args,\n",
    "    train_dataset=dataset[\"train\"],\n",
    "    eval_dataset=dataset[\"test\"],\n",
    "    tokenizer=tokenizer,\n",
    "    data_collator=data_collator,\n",
    ")  # doctest: +SKIP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Psdx0-YaApmn"
   },
   "source": [
    "Когда будете готовы, вызовите [train()](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer.train), чтобы начать обучение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nQQ49c1cApmo"
   },
   "outputs": [],
   "source": [
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fvCo1YNGApmo"
   },
   "source": [
    "<Tip>\n",
    "\n",
    "Если вам нужно выполнить задачи, такие как перевод или краткое изложение, которые используют модель \"последовательность в последовательность\", воспользуйтесь классами [Seq2SeqTrainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Seq2SeqTrainer) и [Seq2SeqTrainingArguments](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Seq2SeqTrainingArguments).\n",
    "\n",
    "</Tip>\n",
    "\n",
    "Вы можете настроить поведение цикла обучения, расширив методы внутри класса [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer). Это позволяет изменять такие параметры, как функция потерь, оптимизатор и планировщик. Ознакомьтесь с документацией [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer), чтобы узнать, какие методы можно расширить.\n",
    "\n",
    "Другой способ настроить цикл обучения — использовать [Callbacks](https://huggingface.co/docs/transformers/main/en/./main_classes/callbacks). С помощью callback-функций можно интегрировать другие библиотеки и следить за прогрессом обучения или приостановить его заранее. Callback'и сами по себе не изменяют ничего в цикле обучения. Чтобы, например, изменить функцию потерь, вам нужно расширить класс [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer)."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}