ImportError: cannot import name 'GPT3ForSequenceClassification' from 'transformers' (/Users/lewtun/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/__init__.py)",
+ explain: "Включение последней строки трассировки может быть описательным, но это лучше оставить для основной части темы. Попробуйте еще раз!"
+ },
+ {
+ text: "Проблема с from transformers import GPT3ForSequenceClassification",
+ explain: "Попробуйте еще раз - хотя это и полезная информация, ее лучше оставить для основной части текста.",
+ },
+ {
+ text: "Почему я не могу импортировать GPT3ForSequenceClassification?",
+ explain: "Отличный выбор! Это название лаконично и дает читателю понять, что может быть не так (например, что GPT-3 не поддерживается в 🤗 Transformers).",
+ correct: true
+ },
+ {
+ text: "Поддерживается ли GPT-3 в 🤗 Transformers?",
+ explain: "Отличный вариант! Использование вопросов в качестве заголовков тем - отличный способ донести проблему до сообщества.",
+ correct: true
+ }
+ ]}
+/>
+
+### 4. Предположим, вы пытаетесь запустить `trainer.train()` и сталкиваетесь с загадочной ошибкой, которая не говорит вам, откуда именно она взялась. Что из нижеперечисленного является первым местом, где вы должны искать ошибки в вашем конвейере обучения?
+
+
+
+### 5. Каков наилучший способ отладки ошибок CUDA?
+
+
+
+### 6. Как лучше всего сообщить о проблеме на GitHub?
+
+
+
+### 7. Почему переобучение модели с одним батчем обычно является хорошим методом отладки?
+
+
+
+### 8. Почему при создании нового вопроса в репозитории 🤗 Transformers стоит указать подробности о вашем окружении разработки с помощью `transformers-cli env`??
+
+
diff --git a/chapters/ru/chapter9/1.mdx b/chapters/ru/chapter9/1.mdx
new file mode 100644
index 000000000..4af88378c
--- /dev/null
+++ b/chapters/ru/chapter9/1.mdx
@@ -0,0 +1,37 @@
+# Введение в Gradio[[introduction-to-gradio]]
+
+
+
+В этой главе мы узнаем о том, как создавать **интерактивные демонстрации** для моделей машинного обучения.
+
+Зачем вообще создавать демо или графический интерфейс для модели машинного обучения? Демо позволяют:
+
+- **Разработчикам машинного обучения** легко представить свою работу широкой аудитории, включая нетехнические команды или клиентов
+- **Исследователям** легче воспроизводить модели машинного обучения и их поведение
+- **Тестировщики качества** или **конечные пользователи**, смогут легче выявлять и отлаживать точки отказа в моделях
+- **Различные пользователи** смогут обнаружить алгоритмические ошибки в моделях
+
+Мы будем использовать библиотеку Gradio для создания демо для наших моделей. Gradio позволяет создавать, настраивать и распространять веб-демо для любой модели машинного обучения, полностью на языке Python.
+
+Вот несколько примеров демо машинного обучения, созданных с помощью Gradio:
+
+* Модель **распознавания эскизов (sketch recognition)**, которая принимает эскиз и выводит метки того, что, по ее мнению, нарисовано:
+
+
+
+* Экстрактивная модель **ответа на вопрос**, которая принимает контекстный параграф и задание и выдает ответ и оценку вероятности (мы обсуждали этот тип модели [в главе 7](../chapter7/7)):
+
+
+
+* Модель **удаления фона**, которая принимает изображение и возвращает его с удаленным фоном:
+
+
+
+Эта глава разбита на разделы, включающие как _концепции_, так и _приложения_. После изучения концепций в каждом разделе вы будете применять их для создания демо определенного типа, начиная от классификации изображений и заканчивая распознаванием речи. К тому времени, как вы закончите эту главу, вы сможете создавать эти демо (и многие другие!) всего в несколько строк кода на Python.
+
+
+👀 Проверьте Hugging Face Spaces чтобы увидеть множество свежих примеров демо машинного обучения, созданных сообществом специалистов по машинному обучению!
+
\ No newline at end of file
diff --git a/chapters/ru/chapter9/2.mdx b/chapters/ru/chapter9/2.mdx
new file mode 100644
index 000000000..04abe6e19
--- /dev/null
+++ b/chapters/ru/chapter9/2.mdx
@@ -0,0 +1,118 @@
+# Создание вашего первого демо[[building-your-first-demo]]
+
+
+
+Давайте начнем с установки Gradio! Поскольку это пакет для Python, просто выполните:
+
+`$ pip install gradio `
+
+Вы можете запускать Gradio где угодно, будь то ваша любимая IDE Python, Jupyter-блокнот или даже Google Colab 🤯!
+Так что установите Gradio везде, где вы используете Python!
+
+Давайте начнем с простого примера "Hello World", чтобы познакомиться с синтаксисом Gradio:
+
+```py
+import gradio as gr
+
+
+def greet(name):
+ return "Hello " + name
+
+
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+
+demo.launch()
+```
+
+Давайте пройдемся по приведенному выше коду:
+
+- Сначала мы определяем функцию `greet()`. В данном случае это простая функция, которая добавляет "Hello" перед вашим именем, но это может быть *любая* функция Python в целом. Например, в приложениях машинного обучения эта функция будет *вызывать модель для прогнозирования* на входных данных и возвращать вывод.
+- Затем мы создаем интерфейс Gradio `Interface` с тремя аргументами, `fn`, `inputs` и `outputs`. Эти аргументы определяют функцию прогнозирования, а также _тип_ входных и выходных компонентов, которые мы хотим получить. В нашем случае оба компонента представляют собой простые текстовые поля.
+- Затем мы вызываем метод `launch()` для созданного нами `Interface`.
+
+Если вы запустите этот код, нижеприведенный интерфейс автоматически появится в блокноте Jupyter/Colab или откроется в браузере на **[http://localhost:7860](http://localhost:7860/)** при запуске из скрипта.
+
+
+
+Попробуйте использовать этот GUI прямо сейчас с собственным именем или другими данными!
+
+Вы заметите, что в этом GUI Gradio автоматически определил имя входного параметра (`name`)
+и применил его в качестве метки поверх текстового поля. Что если вы захотите изменить это?
+Или если вы хотите настроить текстовое поле каким-то другим способом? В этом случае вы можете
+инстанцировать объект класса, представляющий компонент ввода.
+
+Посмотрите на пример ниже:
+
+```py
+import gradio as gr
+
+
+def greet(name):
+ return "Hello " + name
+
+
+# Мы инстанцируем класс Textbox
+textbox = gr.Textbox(label="Type your name here:", placeholder="John Doe", lines=2)
+
+gr.Interface(fn=greet, inputs=textbox, outputs="text").launch()
+```
+
+
+
+Здесь мы создали текстовое поле ввода с меткой, заполнителем и заданным количеством строк.
+То же самое можно сделать и для выходного текстового поля, но мы пока что остановимся на этом.
+
+Мы увидели, что с помощью всего нескольких строк кода Gradio позволяет создать простой интерфейс вокруг любой функции
+с любыми входами и выходами. В этом разделе мы начали с
+простого текстового поля, но в следующих разделах мы рассмотрим другие виды входов и выходов. Теперь давайте рассмотрим применение некоторого NLP в приложении Gradio.
+
+
+## 🤖 Добавление прогнозов модели[[including-model-predictions]]
+
+Теперь давайте рассмотрим простой интерфейс, который позволит продемонстрировать демо модели **генерации текста (text-generation)**, такой как GPT-2.
+
+Мы загрузим нашу модель с помощью функции `pipeline()` из 🤗 Transformers.
+Если вам нужно быстро освежить в памяти материал, вы можете вернуться к [этому разделу в Главе 1](../chapter1/3#text-generation).
+
+Сначала мы определяем функцию прогнозирования, которая принимает текстовую подсказку (text prompt) и возвращает ее завершение текста:
+
+```py
+from transformers import pipeline
+
+model = pipeline("text-generation")
+
+
+def predict(prompt):
+ completion = model(prompt)[0]["generated_text"]
+ return completion
+```
+
+Эта функция завершает введенные вами подсказки, и вы можете запустить ее с вашими собственными подсказками, чтобы посмотреть, как она работает. Вот пример (вы можете получить другое завершение):
+
+```
+predict("My favorite programming language is")
+```
+
+```
+>> My favorite programming language is Haskell. I really enjoyed the Haskell language, but it doesn't have all the features that can be applied to any other language. For example, all it does is compile to a byte array.
+```
+
+Теперь, когда у нас есть функция для генерации прогнозов, мы можем создать и запустить `Interface` таким же образом, как мы делали это ранее:
+
+```py
+import gradio as gr
+
+gr.Interface(fn=predict, inputs="text", outputs="text").launch()
+```
+
+
+Вот и все! Теперь вы можете использовать этот интерфейс для генерации текста с помощью модели GPT-2, как показано ниже 🤯.
+
+
+
+Продолжайте читать, чтобы узнать, как создавать другие виды демо с помощью Gradio!
\ No newline at end of file
diff --git a/chapters/ru/chapter9/3.mdx b/chapters/ru/chapter9/3.mdx
new file mode 100644
index 000000000..005bff120
--- /dev/null
+++ b/chapters/ru/chapter9/3.mdx
@@ -0,0 +1,186 @@
+# Понимание класса Interface[[understanding-the-interface-class]]
+
+
+
+В этом разделе мы подробно рассмотрим класс `Interface` и разберем
+основные параметры, используемые для его создания.
+
+## Как создать Interface[[how-to-create-an-interface]]
+
+Вы заметите, что класс `Interface` имеет 3 обязательных параметра:
+
+`Interface(fn, inputs, outputs, ...)`
+
+Это параметры:
+
+ - `fn`: функция прогнозирования, обернутая интерфейсом Gradio. Эта функция может принимать один или несколько параметров и возвращать одно или несколько значений
+ - `inputs`: тип(ы) компонента(ов) ввода. Gradio предоставляет множество готовых компонентов, таких как `"image"` или `"mic"`.
+ - `outputs`: тип(ы) компонента(ов) вывода. Опять же, Gradio предоставляет множество предварительно созданных компонентов, например, `" image"` или `"label"`.
+
+Полный список компонентов [смотрите в документации Gradio](https://gradio.app/docs). Каждый предварительно созданный компонент можно настроить, инстанцировав соответствующий ему класс.
+
+Например, как мы видели в [предыдущем разделе](../chapter9/2),
+вместо передачи `"textbox"` в параметр `inputs`, вы можете передать компонент `Textbox(lines=7, label="Prompt")` для создания текстового поля с 7 строками и меткой.
+
+Давайте рассмотрим еще один пример, на этот раз с компонентом `Audio`.
+
+## Простой пример со звуком[[a-simple-example-with-audio]]
+
+Как уже говорилось, Gradio предоставляет множество различных входов и выходов.
+Поэтому давайте создадим `Interface`, работающий с аудио.
+
+В этом примере мы создадим функцию audio-to-audio, которая принимает
+аудиофайл и просто переворачивает его.
+
+Для ввода мы будем использовать компонент `Audio`. При использовании компонента `Audio`,
+вы можете указать, будет ли источником звука файл, который загружает пользователь
+или микрофон, с помощью которого пользователь записывает свой голос. В данном случае давайте
+зададим `"microphone"`. Просто ради интереса добавим к `Audio` метку, которая будет гласить
+"Speak here...".
+
+Кроме того, мы хотели бы получать аудио в виде массива numpy, чтобы можно было легко
+"перевернуть" его. Поэтому мы зададим `"type"` в значение `"numpy"`, которое передаст входные
+данные в виде кортежа (`sample_rate`, `data`) в нашу функцию.
+
+Мы также будем использовать компонент вывода `Audio`, который может автоматически
+рендерить кортеж с частотой дискретизации и массивом данных numpy в воспроизводимый аудиофайл.
+В этом случае нам не нужно делать никаких настроек, поэтому мы будем использовать строку
+ярлык `"audio"`.
+
+
+```py
+import numpy as np
+import gradio as gr
+
+
+def reverse_audio(audio):
+ sr, data = audio
+ reversed_audio = (sr, np.flipud(data))
+ return reversed_audio
+
+
+mic = gr.Audio(source="microphone", type="numpy", label="Speak here...")
+gr.Interface(reverse_audio, mic, "audio").launch()
+```
+
+Код, приведенный выше, создаст интерфейс, подобный приведенному ниже (если ваш браузер не
+не запрашивает разрешения на использование микрофона, откройте демо в отдельной вкладке.)
+
+
+
+Теперь вы сможете записать свой голос и услышать, как вы говорите в обратную сторону - жутковато 👻!
+
+## Обработка нескольких входов и выходов[[handling-multiple-inputs-and-outputs]]
+
+Допустим, у нас есть более сложная функция, с несколькими входами и выходами.
+В примере ниже у нас есть функция, которая принимает индекс выпадающего списка, значение слайдера и число,
+и возвращает пример музыкального тона.
+
+Посмотрите, как мы передаем список входных и выходных компонентов,
+и посмотрите, сможете ли вы проследить за тем, что происходит.
+
+Ключевым моментом здесь является то, что когда вы передаете:
+* список входных компонентов, каждый компонент соответствует параметру по порядку.
+* список выходных компонентов, каждый компонент соответствует возвращаемому значению.
+
+В приведенном ниже фрагменте кода показано, как три компонента ввода соответствуют трем аргументам функции `generate_tone()`:
+
+```py
+import numpy as np
+import gradio as gr
+
+notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+
+def generate_tone(note, octave, duration):
+ sr = 48000
+ a4_freq, tones_from_a4 = 440, 12 * (octave - 4) + (note - 9)
+ frequency = a4_freq * 2 ** (tones_from_a4 / 12)
+ duration = int(duration)
+ audio = np.linspace(0, duration, duration * sr)
+ audio = (20000 * np.sin(audio * (2 * np.pi * frequency))).astype(np.int16)
+ return (sr, audio)
+
+
+gr.Interface(
+ generate_tone,
+ [
+ gr.Dropdown(notes, type="index"),
+ gr.Slider(minimum=4, maximum=6, step=1),
+ gr.Textbox(type="number", value=1, label="Duration in seconds"),
+ ],
+ "audio",
+).launch()
+```
+
+
+
+
+### Метод `launch()`[[the-launch-method]]
+
+До сих пор мы использовали метод `launch()` для запуска интерфейса, но мы
+не обсуждали, что он делает.
+
+По умолчанию метод `launch()` запускает демо на веб-сервере, который
+работает локально. Если вы выполняете свой код в блокноте Jupyter или Colab, то
+Gradio встроит демо GUI в блокнот, чтобы вы могли легко им пользоваться.
+
+Вы можете настроить поведение `launch()` с помощью различных параметров:
+
+ - `inline` - отображать ли интерфейс в виде строки в блокнотах Python.
+ - `inbrowser` - автоматически ли запускать интерфейс в новой вкладке браузера по умолчанию.
+ - `share` - создавать ли для интерфейса общедоступную ссылку с вашего компьютера. Что-то вроде ссылки на Google Drive!
+
+Мы рассмотрим параметр `share` более подробно в следующем разделе!
+
+## ✏️ Давайте применим это![[lets-apply-it]]
+
+Давайте создадим интерфейс, который позволит вам продемонстрировать демо модели **распознавания речи**.
+Чтобы было интереснее, мы будем принимать *либо* микрофонный вход, либо загруженный файл.
+
+Как обычно, мы загрузим нашу модель распознавания речи с помощью функции `pipeline()` из 🤗 Transformers.
+Если вам нужно быстро вспомнить, вы можете вернуться к [этому разделу в Главе 1](../chapter1/3). Далее мы реализуем функцию `transcribe_audio()`, которая обрабатывает аудио и возвращает транскрипцию. Наконец, мы обернем эту функцию в `Interface` с компонентами `Audio` на входе и просто текстом на выходе. В целом, код этого приложения выглядит следующим образом:
+
+```py
+from transformers import pipeline
+import gradio as gr
+
+model = pipeline("automatic-speech-recognition")
+
+
+def transcribe_audio(mic=None, file=None):
+ if mic is not None:
+ audio = mic
+ elif file is not None:
+ audio = file
+ else:
+ return "You must either provide a mic recording or a file"
+ transcription = model(audio)["text"]
+ return transcription
+
+
+gr.Interface(
+ fn=transcribe_audio,
+ inputs=[
+ gr.Audio(source="microphone", type="filepath", optional=True),
+ gr.Audio(source="upload", type="filepath", optional=True),
+ ],
+ outputs="text",
+).launch()
+```
+
+Если ваш браузер не запрашивает разрешения на использование микрофона, откройте демо в отдельной вкладке.
+
+
+
+
+Вот и все! Теперь вы можете использовать этот интерфейс для транскрибирования аудио. Обратите внимание, что
+передавая параметр `optional` как `True`, мы позволяем пользователю предоставить
+либо микрофон, либо аудиофайл (либо ни то, ни другое, но в этом случае будет выдано сообщение об ошибке).
+
+Продолжайте, чтобы узнать, как поделиться своим интерфейсом с другими!
\ No newline at end of file
diff --git a/chapters/ru/chapter9/4.mdx b/chapters/ru/chapter9/4.mdx
new file mode 100644
index 000000000..08584cea3
--- /dev/null
+++ b/chapters/ru/chapter9/4.mdx
@@ -0,0 +1,147 @@
+# Делимся демо с другими[[sharing-demos-with-others]]
+
+
+
+Теперь, когда вы создали демо, вы наверняка захотите поделиться им с другими. Демо Gradio
+можно распространять двумя способами: используя ***временную ссылку для общего доступа*** или ***постоянный хостинг на Spaces***.
+
+Мы рассмотрим оба этих подхода в ближайшее время. Но прежде чем выложить свое демо, вы, возможно, захотите доработать его 💅.
+
+### Доработка демо Gradio:[[polishing-your-gradio-demo]]
+
+
+
+
+
+"""
+
+article = "Check out [the original Rick and Morty Bot](https://huggingface.co/spaces/kingabzpro/Rick_and_Morty_Bot) that this demo is based off of."
+
+gr.Interface(
+ fn=predict,
+ inputs="textbox",
+ outputs="text",
+ title=title,
+ description=description,
+ article=article,
+ examples=[["What are you doing?"], ["Where should we time travel to?"]],
+).launch()
+```
+
+Используя приведенные выше варианты, мы получим более завершенный интерфейс. Попробуйте интерфейс, представленный ниже:
+
+
+
+### Распространение демо с помощью временных ссылок[[sharing-your-demo-with-temporary-links]]
+Теперь, когда у нас есть работающее демо нашей модели машинного обучения, давайте узнаем, как легко поделиться ссылкой на наш интерфейс.
+Интерфейсами можно легко поделиться публично, установив `share=True` в методе `launch()`:
+
+```python
+gr.Interface(classify_image, "image", "label").launch(share=True)
+```
+
+В результате создается общедоступная ссылка, которую вы можете отправить кому угодно! Когда вы отправляете эту ссылку, пользователь на другой стороне может опробовать модель в своем браузере в течение 72 часов. Поскольку обработка происходит на вашем устройстве (пока оно включено!), вам не нужно беспокоиться об упаковке каких-либо зависимостей. Если вы работаете в блокноте Google Colab, ссылка на общий доступ всегда создается автоматически. Обычно она выглядит примерно так: **XXXXX.gradio.app**. Хотя ссылка предоставляется через Gradio, мы являемся лишь прокси для вашего локального сервера и не храним никаких данных, передаваемых через интерфейсы.
+
+Однако не забывайте, что эти ссылки общедоступны, а значит, любой желающий может использовать вашу модель для прогнозирования! Поэтому не раскрывайте конфиденциальную информацию через написанные вами функции и не допускайте критических изменений на вашем устройстве. Если вы установите `share=False` (по умолчанию), будет создана только локальная ссылка.
+
+### Хостинг вашего демо на Hugging Face Spaces[[hosting-your-demo-on-hugging-face-spaces]]
+
+Ссылка на ресурс, которую можно передать коллегам, - это здорово, но как разместить демо на постоянном хостинге, чтобы оно существовало в своем собственном "пространстве (space)" в Интернете?
+
+Hugging Face Spaces предоставляет инфраструктуру для постоянного размещения вашей модели Gradio в интернете, **бесплатно**! Spaces позволяет вам создать и разместить в (публичном или частном) репозитории,
+где ваш Gradio
+код интерфейса будет существовать в файле `app.py`. [Прочитайте пошаговое руководство](https://huggingface.co/blog/gradio-spaces) чтобы начать работу, или посмотрите видео с примером ниже.
+
+
+
+## ✏️ Давайте применим это![[lets-apply-it]]
+
+Используя то, что мы узнали в предыдущих разделах, давайте создадим демо распознавания скетчей, которое мы видели в [первом разделе этой главы](../chapter9/1). Давайте добавим некоторые настройки в наш интерфейс и установим `share=True`, чтобы создать публичную ссылку, которую мы сможем передавать всем желающим.
+
+Мы можем загрузить метки из файла [class_names.txt](https://huggingface.co/spaces/dawood/Sketch-Recognition/blob/main/class_names.txt) и загрузить предварительно обученную модель pytorch из файла [pytorch_model.bin](https://huggingface.co/spaces/dawood/Sketch-Recognition/blob/main/pytorch_model.bin). Загрузите эти файлы, перейдя по ссылке и нажав кнопку загрузки в левом верхнем углу окна предварительного просмотра файла. Давайте посмотрим на приведенный ниже код, чтобы увидеть, как мы используем эти файлы для загрузки нашей модели и создания функции `predict()`:
+```py
+from pathlib import Path
+import torch
+import gradio as gr
+from torch import nn
+
+LABELS = Path("class_names.txt").read_text().splitlines()
+
+model = nn.Sequential(
+ nn.Conv2d(1, 32, 3, padding="same"),
+ nn.ReLU(),
+ nn.MaxPool2d(2),
+ nn.Conv2d(32, 64, 3, padding="same"),
+ nn.ReLU(),
+ nn.MaxPool2d(2),
+ nn.Conv2d(64, 128, 3, padding="same"),
+ nn.ReLU(),
+ nn.MaxPool2d(2),
+ nn.Flatten(),
+ nn.Linear(1152, 256),
+ nn.ReLU(),
+ nn.Linear(256, len(LABELS)),
+)
+state_dict = torch.load("pytorch_model.bin", map_location="cpu")
+model.load_state_dict(state_dict, strict=False)
+model.eval()
+
+
+def predict(im):
+ x = torch.tensor(im, dtype=torch.float32).unsqueeze(0).unsqueeze(0) / 255.0
+ with torch.no_grad():
+ out = model(x)
+ probabilities = torch.nn.functional.softmax(out[0], dim=0)
+ values, indices = torch.topk(probabilities, 5)
+ return {LABELS[i]: v.item() for i, v in zip(indices, values)}
+```
+
+Теперь у нас есть функция `predict()`. Следующим шагом будет определение и запуск нашего интерфейса Gradio:
+
+```py
+interface = gr.Interface(
+ predict,
+ inputs="sketchpad",
+ outputs="label",
+ theme="huggingface",
+ title="Sketch Recognition",
+ description="Who wants to play Pictionary? Draw a common object like a shovel or a laptop, and the algorithm will guess in real time!",
+ article="Sketch Recognition | Demo Model
",
+ live=True,
+)
+interface.launch(share=True)
+```
+
+
+
+
+Обратите внимание на параметр `live=True` в `Interface`, который означает, что демо скетча делает
+предсказание каждый раз, когда кто-то рисует на скетчпаде (без кнопки "Исполнить (submit)"!).
+
+Кроме того, мы также установили аргумент `share=True` в методе `launch()`.
+Это создаст общедоступную ссылку, которую вы можете
+отправить кому угодно! Когда вы отправите эту ссылку, пользователь на другой стороне сможет опробовать
+модель распознавания эскизов. Повторим, что модель также можно разместить на Hugging Face Spaces,
+именно так мы и разместили демо выше.
+
+Далее мы расскажем о других способах использования Gradio в экосистеме Hugging Face!
\ No newline at end of file
diff --git a/chapters/ru/chapter9/5.mdx b/chapters/ru/chapter9/5.mdx
new file mode 100644
index 000000000..8e180118d
--- /dev/null
+++ b/chapters/ru/chapter9/5.mdx
@@ -0,0 +1,67 @@
+# Интеграция с Hugging Face Hub[[integrations-with-the-hugging-face-hub]]
+
+
+
+Чтобы сделать вашу жизнь еще проще, Gradio напрямую интегрируется с Hugging Face Hub и Hugging Face Spaces.
+Вы можете загружать демо из Hub и Spaces, используя всего *одну строку кода*.
+
+### Загрузка моделей из Hugging Face Hub[[loading-models-from-the-hugging-face-hub]]
+Для начала выберите одну из тысяч моделей, которые Hugging Face предлагает в Hub, как описано в [Главе 4](../chapter4/2).
+
+Используя специальный метод `Interface.load()`, вы передаете `"model/"` (или, эквивалентно, `"huggingface/"`)
+после чего следует имя модели.
+Например, здесь приведен код для создания демо для [GPT-J](https://huggingface.co/EleutherAI/gpt-j-6B), большой языковой модели, добавьте пару примеров ввода:
+
+```py
+import gradio as gr
+
+title = "GPT-J-6B"
+description = "Gradio Demo for GPT-J 6B, a transformer model trained using Ben Wang's Mesh Transformer JAX. 'GPT-J' refers to the class of model, while '6B' represents the number of trainable parameters. To use it, simply add your text, or click one of the examples to load them. Read more at the links below."
+article = "GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model
"
+
+gr.Interface.load(
+ "huggingface/EleutherAI/gpt-j-6B",
+ inputs=gr.Textbox(lines=5, label="Input Text"),
+ title=title,
+ description=description,
+ article=article,
+).launch()
+```
+
+Код, приведенный выше, приведет к созданию интерфейса, представленного ниже:
+
+
+
+Загрузка модели таким образом использует [Inference API](https://huggingface.co/inference-api) Hugging Face,
+вместо того, чтобы загружать модель в память. Это идеально подходит для огромных моделей, таких как GPT-J или T0pp, которые
+ которые требуют много RAM.
+
+### Загрузка с Hugging Face Spaces[[loading-from-hugging-face-spaces]]
+Чтобы загрузить любое пространство (Space) из Hugging Face Hub и воссоздать его локально, вы можете передать `spaces/` в `Interface`, за которым следует имя пространства.
+
+Помните демо из раздела 1, которое удаляет фон изображения? Давайте загрузим его из Hugging Face Spaces:
+
+```py
+gr.Interface.load("spaces/abidlabs/remove-bg").launch()
+```
+
+
+
+Одна из особенностей загрузки демо из Hub или Spaces заключается в том, что вы можете настраивать их
+переопределив любой из
+параметров. Здесь мы добавим заголовок и задействуем веб-камеру:
+
+```py
+gr.Interface.load(
+ "spaces/abidlabs/remove-bg", inputs="webcam", title="Remove your webcam background!"
+).launch()
+```
+
+
+
+Теперь, когда мы изучили несколько способов интеграции Gradio с Hugging Face Hub, давайте рассмотрим некоторые дополнительные возможности класса `Interface`. Этому будет посвящен следующий раздел!
\ No newline at end of file
diff --git a/chapters/ru/chapter9/6.mdx b/chapters/ru/chapter9/6.mdx
new file mode 100644
index 000000000..202e47b0f
--- /dev/null
+++ b/chapters/ru/chapter9/6.mdx
@@ -0,0 +1,101 @@
+# Расширенные возможности Interface[[advanced-interface-features]]
+
+
+
+Теперь, когда мы можем создать базовый интерфейс и поделиться им, давайте изучим некоторые более продвинутые возможности, такие как состояние и интерпретации.
+
+### Использование состояния для сохранения данных[[using-state-to-persist-data]]
+
+Gradio поддерживает *состояние сеанса*, когда данные сохраняются при нескольких отправках в рамках
+загруженной страницы. Состояние сессии полезно для создания демо, например, чат-ботов, где необходимо
+сохранять данные по мере того, как пользователь взаимодействует с моделью. Обратите внимание, что состояние сессии не позволяет обмениваться данными между разными пользователями вашей модели.
+
+Чтобы хранить данные о состоянии сеанса, необходимо выполнить три действия:
+
+1. Передайте в вашу функцию *дополнительный параметр*, который представляет собой состояние интерфейса.
+2. В завершении работы функции верните обновленное значение состояния в качестве *дополнительного возвращаемого значения*.
+3. Добавьте входной компонент 'state' и выходной компонент 'state' при создании вашего `Interface`.
+
+Посмотрите пример чатбота ниже:
+
+```py
+import random
+
+import gradio as gr
+
+
+def chat(message, history):
+ history = history or []
+ if message.startswith("How many"):
+ response = random.randint(1, 10)
+ elif message.startswith("How"):
+ response = random.choice(["Great", "Good", "Okay", "Bad"])
+ elif message.startswith("Where"):
+ response = random.choice(["Here", "There", "Somewhere"])
+ else:
+ response = "I don't know"
+ history.append((message, response))
+ return history, history
+
+
+iface = gr.Interface(
+ chat,
+ ["text", "state"],
+ ["chatbot", "state"],
+ allow_screenshot=False,
+ allow_flagging="never",
+)
+iface.launch()
+```
+
+
+
+Обратите внимание, что состояние выходного компонента сохраняется при всех отправках данных.
+Примечание: в параметр state можно передать значение по умолчанию,
+которое используется в качестве начального значения состояния.
+
+### Использование интерпретации для понимания прогнозов[[using-interpretation-to-understand-predictions]]
+
+Большинство моделей машинного обучения представляют собой "черные ящики", и внутренняя логика функции скрыта от конечного пользователя. Чтобы стимулировать прозрачность, мы упростили добавление интерпретации в вашу модель, просто задав ключевое слово interpretation в классе Interface по умолчанию. Это позволит вашим пользователям понять, какие части входных данных отвечают за вывод. Взгляните на простой интерфейс ниже, который показывает классификатор изображений, также включающий интерпретацию:
+
+```py
+import requests
+import tensorflow as tf
+
+import gradio as gr
+
+inception_net = tf.keras.applications.MobileNetV2() # загрузим модель
+
+# Загрузим человекочитаемые метки для ImageNet.
+response = requests.get("https://git.io/JJkYN")
+labels = response.text.split("\n")
+
+
+def classify_image(inp):
+ inp = inp.reshape((-1, 224, 224, 3))
+ inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp)
+ prediction = inception_net.predict(inp).flatten()
+ return {labels[i]: float(prediction[i]) for i in range(1000)}
+
+
+image = gr.Image(shape=(224, 224))
+label = gr.Label(num_top_classes=3)
+
+title = "Gradio Image Classifiction + Interpretation Example"
+gr.Interface(
+ fn=classify_image, inputs=image, outputs=label, interpretation="default", title=title
+).launch()
+```
+
+Проверьте функцию интерпретации, отправив входные данные и нажав кнопку Интерпретировать (Interpret) под компонентом вывода.
+
+
+
+Помимо метода интерпретации, предоставляемого Gradio по умолчанию, вы также можете задать `shap` для параметра `interpretation` и установить параметр `num_shap`. При этом используется интерпретация на основе Шэпли, о которой вы можете подробнее прочитать [здесь](https://christophm.github.io/interpretable-ml-book/shap.html). Наконец, в параметр `interpretation` можно передать собственную функцию интерпретации. Пример можно посмотреть на странице Gradio, посвященной началу работы [здесь](https://gradio.app/getting_started/).
+
+На этом мы завершаем наше глубокое погружение в класс `Interface` в Gradio. Как мы уже видели, этот класс позволяет создавать демо машинного обучения в несколько строк кода на Python. Однако иногда возникает необходимость доработать демо, изменив его макет или соединив несколько функций предсказания в цепочку. Было бы здорово, если бы мы могли как-то разделить `Interface` на настраиваемые "блоки"? К счастью, такая возможность есть! Этой теме посвящен последний раздел.
\ No newline at end of file
diff --git a/chapters/ru/chapter9/7.mdx b/chapters/ru/chapter9/7.mdx
new file mode 100644
index 000000000..de0e1f8db
--- /dev/null
+++ b/chapters/ru/chapter9/7.mdx
@@ -0,0 +1,239 @@
+# Введение в Gradio Blocks[[introduction-to-gradio-blocks]]
+
+
+
+В предыдущих разделах мы изучили и создали демо, используя класс `Interface`. В этом разделе мы представим наш **свеже разработанный** низкоуровневый API под названием `gradio.Blocks`.
+
+Итак, в чем разница между `Interface` и `Blocks`?
+
+- ⚡ `Interface`: высокоуровневый API, который позволяет создать полноценное демо машинного обучения, просто предоставив список входных и выходных данных.
+
+- 🧱 `Blocks`: низкоуровневый API, который позволяет вам полностью контролировать потоки данных и компоновку вашего приложения. Вы можете создавать очень сложные, многоступенчатые приложения, используя `Blocks` (как "строительные блоки").
+
+
+### Почему Blocks 🧱?[[why-blocks-]]
+
+Как мы видели в предыдущих разделах, класс `Interface` позволяет легко создавать полноценные демо машинного обучения с помощью всего нескольких строк кода. API `Interface` чрезвычайно прост в использовании, но ему не хватает гибкости, которую обеспечивает API `Blocks`. Например, вы можете захотеть:
+
+- Сгруппировать связанные демо в виде нескольких вкладок в одном веб-приложении
+- Изменить макет вашего демо, например, указать, где расположены входные и выходные компоненты
+- Многоступенчатые интерфейсы, в которых выход одной модели становится входом для следующей модели, или более гибкие потоки данных в целом
+- Изменить свойства компонента (например, выбор в выпадающем списке) или его видимость на основе пользовательского ввода
+
+Ниже мы рассмотрим все эти понятия.
+
+### Создание простого демо с помощью блоков[[creating-a-simple-demo-using-blocks]]
+
+После того как вы установили Gradio, запустите приведенный ниже код в виде сценария на Python, блокнота Jupyter или блокнота Colab.
+
+```py
+import gradio as gr
+
+
+def flip_text(x):
+ return x[::-1]
+
+
+demo = gr.Blocks()
+
+with demo:
+ gr.Markdown(
+ """
+ # Flip Text!
+ Start typing below to see the output.
+ """
+ )
+ input = gr.Textbox(placeholder="Flip this text")
+ output = gr.Textbox()
+
+ input.change(fn=flip_text, inputs=input, outputs=output)
+
+demo.launch()
+```
+
+
+
+В этом простом примере представлены 4 концепции, которые лежат в основе блоков:
+
+1. Блоки позволяют создавать веб-приложения, сочетающие в себе разметку, HTML, кнопки и интерактивные компоненты, просто инстанцируя объекты на Python в контексте `with gradio.Blocks`.
+
+
+🙋Если вы не знакомы с оператором `with` в Python, рекомендуем ознакомиться с отличным [руководством](https://realpython.com/python-with-statement/) от Real Python. Возвращайтесь сюда после его прочтения 🤗
+
+
+
+Порядок, в котором вы инстанцируете компоненты, имеет значение, поскольку каждый элемент отображается в веб-приложении в том порядке, в котором он был создан. (Более сложные макеты рассматриваются ниже)
+
+2. Вы можете определять обычные функции Python в любом месте вашего кода и запускать их с пользовательским вводом с помощью `Blocks`. В нашем примере мы используем простую функцию, которая "переворачивает" введенный текст, но вы можете написать любую функцию Python, от простого вычисления до обработки прогнозов модели машинного обучения.
+
+3. Вы можете назначить события для любого компонента `Blocks`. Это позволит запускать вашу функцию при нажатии на компонент, его изменении и т. д. Когда вы назначаете событие, вы передаете три параметра: `fn`: функция, которая должна быть вызвана, `inputs`: (список) входных компонентов, и `outputs`: (список) выходных компонентов, которые должны быть вызваны.
+
+ В примере выше мы запускаем функцию `flip_text()`, когда значение в `Textbox` с названием `input` изменяется. Событие считывает значение в `input`, передает его в качестве именнованного параметра в `flip_text()`, которая затем возвращает значение, которое присваивается нашему второму `Textbox` с именем `output`.
+
+ Список событий, которые поддерживает каждый компонент, можно найти в [документации Gradio](https://www.gradio.app/docs/).
+
+4. Блоки автоматически определяют, должен ли компонент быть интерактивным (принимать пользовательский ввод) или нет, основываясь на определенных вами триггерах событий. В нашем примере первый textbox является интерактивным, поскольку его значение используется функцией `flip_text()`. Второй textbox не является интерактивным, поскольку его значение никогда не используется в качестве входа. В некоторых случаях вы можете переопределить это, передав булево значение в параметр `interactive` компонента (например, `gr.Textbox(placeholder="Flip this text", interactive=True)`).
+
+### Настройка макета вашего демо[[customizing-the-layout-of-your-demo]]
+
+Как мы можем использовать `Blocks` для настройки макета нашего демо? По умолчанию `Blocks` отображает созданные вами компоненты вертикально в одной колонке. Вы можете изменить это, создав дополнительные колонки `с помощью gradio.Column():` или строки `с помощью gradio.Row():` и создав компоненты в этих контекстах.
+
+Вот что следует иметь в виду: все компоненты, созданные в `Column` (это также значение по умолчанию), будут располагаться вертикально. Любой компонент, созданный в `Row`, будет располагаться горизонтально, аналогично [модели flexbox в веб-разработке](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox).
+
+Наконец, вы можете создавать вкладки для демо с помощью контекстного менеджера `with gradio.Tabs()`. В этом контексте вы можете создать несколько вкладок, указав дочерние вкладки в `with gradio.TabItem(name_of_tab):` . Любой компонент, созданный внутри контекста `with gradio.TabItem(name_of_tab):`, отображается на этой вкладке.
+
+Теперь давайте добавим функцию `flip_image()` в наше демо и добавим новую вкладку, которая будет переворачивать изображения. Ниже приведен пример с 2 вкладками, в котором также используется Row:
+
+```py
+import numpy as np
+import gradio as gr
+
+demo = gr.Blocks()
+
+
+def flip_text(x):
+ return x[::-1]
+
+
+def flip_image(x):
+ return np.fliplr(x)
+
+
+with demo:
+ gr.Markdown("Flip text or image files using this demo.")
+ with gr.Tabs():
+ with gr.TabItem("Flip Text"):
+ with gr.Row():
+ text_input = gr.Textbox()
+ text_output = gr.Textbox()
+ text_button = gr.Button("Flip")
+ with gr.TabItem("Flip Image"):
+ with gr.Row():
+ image_input = gr.Image()
+ image_output = gr.Image()
+ image_button = gr.Button("Flip")
+
+ text_button.click(flip_text, inputs=text_input, outputs=text_output)
+ image_button.click(flip_image, inputs=image_input, outputs=image_output)
+
+demo.launch()
+```
+
+
+
+
+Вы заметите, что в этом примере мы также создали компонент `Button` на каждой вкладке и назначили событие click для каждой кнопки, что, собственно, и запускает функцию.
+
+### Изучение событий и состояния[[exploring-events-and-state]]
+
+Так же, как вы можете управлять макетом, `Blocks` дает вам тонкий контроль над тем, какие события вызывают вызовы функций. Каждый компонент и многие макеты имеют определенные события, которые они поддерживают.
+
+Например, у компонента `Textbox` есть 2 события: `change()` (когда меняется значение внутри текстового поля) и `submit()` (когда пользователь нажимает клавишу ввода, будучи сфокусированным на текстовом поле). Более сложные компоненты могут иметь еще больше событий: например, компонент `Audio` также имеет отдельные события для воспроизведения аудиофайла, очистки, приостановки и так далее. О том, какие события поддерживает каждый компонент, читайте в документации.
+
+Вы можете прикрепить триггер события ни к одному, одному или нескольким из этих событий. Вы создаете триггер события, вызывая имя события на экземпляре компонента в виде функции - например, `textbox.change(...)` или `btn.click(...)`. Функция принимает три параметра, как говорилось выше:
+
+- `fn`: функция для выполнения
+- `inputs`: (список (list)) компонент(ов), значения которых должны быть переданы в качестве входных параметров функции. Значение каждого компонента по порядку сопоставляется с соответствующим параметром функции. Этот параметр может иметь значение None, если функция не принимает никаких параметров.
+- `outputs`: (список (list)) компонентов, значения которых должны быть обновлены на основе значений, возвращаемых функцией. Каждое возвращаемое значение устанавливает значение соответствующего компонента по порядку. Этот параметр может быть None, если функция ничего не возвращает.
+
+Вы даже можете сделать так, чтобы компонент ввода и компонент вывода были одним и тем же компонентом, как это сделано в данном примере, где используется модель GPT для дополнения текста:
+
+```py
+import gradio as gr
+
+api = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
+
+
+def complete_with_gpt(text):
+ # Используем последние 50 символов текста в качестве контекста
+ return text[:-50] + api(text[-50:])
+
+
+with gr.Blocks() as demo:
+ textbox = gr.Textbox(placeholder="Type here and press enter...", lines=4)
+ btn = gr.Button("Generate")
+
+ btn.click(complete_with_gpt, textbox, textbox)
+
+demo.launch()
+```
+
+
+
+### Создание многоступенчатых демо[[creating-multi-step-demos]]
+
+В некоторых случаях вам может понадобиться _многоступенчатое демо_, в котором вы повторно используете выход одной функции в качестве входа для следующей. Это очень легко сделать с помощью `Blocks`, так как вы можете использовать компонент в качестве входа для одного триггера события, но выхода для другого. Посмотрите на компонент text в примере ниже: его значение является результатом работы модели преобразования речи в текст, но также передается в модель анализа настроений:
+
+```py
+from transformers import pipeline
+
+import gradio as gr
+
+asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
+classifier = pipeline("text-classification")
+
+
+def speech_to_text(speech):
+ text = asr(speech)["text"]
+ return text
+
+
+def text_to_sentiment(text):
+ return classifier(text)[0]["label"]
+
+
+demo = gr.Blocks()
+
+with demo:
+ audio_file = gr.Audio(type="filepath")
+ text = gr.Textbox()
+ label = gr.Label()
+
+ b1 = gr.Button("Recognize Speech")
+ b2 = gr.Button("Classify Sentiment")
+
+ b1.click(speech_to_text, inputs=audio_file, outputs=text)
+ b2.click(text_to_sentiment, inputs=text, outputs=label)
+
+demo.launch()
+```
+
+
+
+### Обновление свойств компонента[[updating-component-properties]]
+
+До сих пор мы видели, как создавать события для обновления значения другого компонента. Но что делать, если вы хотите изменить другие свойства компонента, например видимость текстового поля или варианты выбора в группе радио кнопок? Вы можете сделать это, вернув метод класса компонента `update()` вместо обычного возвращаемого значения из вашей функции.
+
+Это легче всего проиллюстрировать на примере:
+
+```py
+import gradio as gr
+
+
+def change_textbox(choice):
+ if choice == "short":
+ return gr.Textbox.update(lines=2, visible=True)
+ elif choice == "long":
+ return gr.Textbox.update(lines=8, visible=True)
+ else:
+ return gr.Textbox.update(visible=False)
+
+
+with gr.Blocks() as block:
+ radio = gr.Radio(
+ ["short", "long", "none"], label="What kind of essay would you like to write?"
+ )
+ text = gr.Textbox(lines=2, interactive=True)
+
+ radio.change(fn=change_textbox, inputs=radio, outputs=text)
+ block.launch()
+```
+
+
+
+Мы только что изучили все основные концепции `Blocks`! Как и в случае с `Interfaces`, вы можете создавать классные демо, которыми можно поделиться, используя `share=True` в методе `launch()` или развернуть на [Hugging Face Spaces](https://huggingface.co/spaces).
\ No newline at end of file
diff --git a/chapters/ru/chapter9/8.mdx b/chapters/ru/chapter9/8.mdx
new file mode 100644
index 000000000..179e3eee0
--- /dev/null
+++ b/chapters/ru/chapter9/8.mdx
@@ -0,0 +1,24 @@
+# Gradio, проверка![[gradio-check]]
+
+
+
+На этом мы завершаем главу о создании классных демо на основе ML с помощью Gradio - надеемся, вам понравилось! Напомним, что в этой главе мы узнали:
+
+- Как создавать демо Gradio с помощью высокоуровневого API `Interface` и как настраивать различные модальности ввода и вывода.
+- Различные способы поделиться демо Gradio, с помощью временных ссылок и хостинга на [Hugging Face Spaces](https://huggingface.co/spaces).
+- Как интегрировать демо Gradio с моделями и Spaces на Hugging Face Hub.
+- Расширенные возможности, такие как хранение состояния в демо или обеспечение аутентификации.
+- Как получить полный контроль над потоком данных и макетом демо с помощью Gradio Blocks.
+
+Если вы хотите проверить свое понимание концепций, рассмотренных в этой главе, пройдите тест в следующем разделе!
+
+## Что дальше?[[where-to-next]]
+
+Если вы хотите узнать больше о Gradio, вы можете
+
+- Взглянуть на [Demo](https://github.com/gradio-app/gradio/tree/main/demo) репозиторий, там довольно много примеров.
+- Посмотреть страницу [Guides](https://gradio.app/guides/), где вы можете найти руководства о крутых и продвинутых функциях.
+- Заглянуть на страницу [Docs](https://gradio.app/docs/), чтобы узнать детали.
diff --git a/chapters/ru/chapter9/9.mdx b/chapters/ru/chapter9/9.mdx
new file mode 100644
index 000000000..74ce11f5d
--- /dev/null
+++ b/chapters/ru/chapter9/9.mdx
@@ -0,0 +1,239 @@
+
+
+# Тест в конце главы[[end-of-chapter-quiz]]
+
+
+
+Давайте проверим, чему вы научились в этой главе!
+
+### 1. Для чего можно использовать Gradio?
+
+share=True в методе запуска, вы можете сгенерировать ссылку для общего доступа, чтобы отправить ее всем желающим.",
+ correct: true
+ },
+ {
+ text: "Отладка вашей модели",
+ explain: "Одно из преимуществ демо Gradio - возможность протестировать модель на реальных данных, которые можно изменять и наблюдать за изменением прогнозов модели в режиме реального времени, что поможет вам отладить модель.",
+ correct: true
+ },
+ {
+ text: "Обучить вашу модель",
+ explain: "Gradio разработана для инференса модели, ПОСЛЕ того как модель обучена.",
+ }
+ ]}
+/>
+
+### 2. Gradio работает ТОЛЬКО с моделями PyTorch
+
+
+
+### 3. Где можно запустить демо Gradio?
+
+
+
+### 4. Gradio предназначен в первую очередь для моделей NLP
+
+
+
+### 5. Какие из следующих функций поддерживаются Gradio?
+
+gr.Interface.load().",
+ correct: true
+ }
+ ]}
+/>
+
+### 6. Какие из следующих способов загрузки модели Hugging Face из Hub или Spaces являются правильными?
+
+
+
+### 7. Выберите все шаги, необходимые для добавления состояния в интерфейс Gradio
+
+
+
+### 8. Какие из перечисленных ниже компонентов входят в библиотеку Gradio?
+
+
+
+### 9. Что позволяет делать Gradio `Blocks`?
+
+
+
+### 10. Вы можете поделиться публичной ссылкой на демо `Blocks` и разместить демо `Blocks` в пространстве Hugging Face.
+
+
\ No newline at end of file
diff --git a/chapters/ru/events/1.mdx b/chapters/ru/events/1.mdx
new file mode 100644
index 000000000..5b94f5eb6
--- /dev/null
+++ b/chapters/ru/events/1.mdx
@@ -0,0 +1,34 @@
+# Занятия и семинары[[live-sessions-and-workshops]]
+
+В связи с выходом первой и второй частей курса мы организовали несколько занятий и семинаров по программированию. Ссылки на записи этих сессий и семинаров вы можете найти ниже.
+
+## Занятия по программированию[[live-coding-sessions]]
+
+На первом занятии Сильвен вместе с вами изучит Главу 1 курса, объясняя ее шаг за шагом:
+
+
+
+На втором занятии настал черед Льюиса представить главу 2:
+
+
+
+Поскольку Глава 2 настолько классная, Сильвен также сделал видео к ней!
+
+
+
+В Главе 3 Льюис возвращается, чтобы обьяснить вам код:
+
+
+
+Наконец, Омар завершает занятия, связанные с первой частью курса, рассмотрением главы 4:
+
+
+
+## Семинары[[workshops]]
+На первом семинаре Мерве приглашает Льюиса обсудить раздел 7 главы 7, посвященный задаче [ответа на вопросы](https://huggingface.co/learn/nlp-course/ru/chapter7/7).
+
+
+
+На втором семинаре Мерве приглашает Леандро рассказать о 6 разделе 7 главы, посвященном [обучению каузальной языковой модели с нуля](https://huggingface.co/learn/nlp-course/ru/chapter7/6) и приложению [CodeParrot](https://huggingface.co/codeparrot).
+
+
diff --git a/chapters/ru/events/2.mdx b/chapters/ru/events/2.mdx
new file mode 100644
index 000000000..443cc1167
--- /dev/null
+++ b/chapters/ru/events/2.mdx
@@ -0,0 +1,135 @@
+# Событие посвященное выходу 2 части курса[[part-2-release-event]]
+
+В связи с выходом второй части курса мы организовали живую встречу с двумя днями выступлений перед спринтом по доработке. Если вы пропустили это мероприятие, вы можете просмотреть все выступления, которые перечислены ниже!
+
+## День 1: Высокоуровневое представление о трансформерах и о том, как их обучать[[day-1-a-high-level-view-of-transformers-and-how-to-train-them]]
+
+**Томас Вульф:** *Трансферное обучение и рождение библиотеки Transformers*
+
+
+
+
+
+
+
+Томас Вольф - соучредитель и главный научный директор компании Hugging Face. Инструменты, созданные Томасом Вольфом и командой Hugging Face, используются более чем в 5 000 исследовательских организаций, включая Facebook Artificial Intelligence Research, Google Research, DeepMind, Amazon Research, Apple, Институт искусственного интеллекта Аллена, а также большинство университетских факультетов. Томас Вольф является инициатором и старшим председателем крупнейшей исследовательской коллаборации, когда-либо существовавшей в области искусственного интеллекта: ["BigScience"](https://bigscience.huggingface.co), а также набора широко используемых [библиотек и инструментов](https://github.com/huggingface/). Томас Вольф также является активным преподавателем, идейным лидером в области искусственного интеллекта и обработки естественного языка и постоянным приглашенным докладчиком на конференциях по всему миру [https://thomwolf.io](https://thomwolf.io).
+
+**Джей Аламмар:** *Легкое визуальное введение в модели трансформеры*
+
+
+
+
+
+
+
+Благодаря своему популярному блогу Джей помог миллионам исследователей и инженеров наглядно понять инструменты и концепции машинного обучения - от базовых (заканчивая документами по NumPy, Pandas) до самых современных (Transformers, BERT, GPT-3).
+
+**Маргарет Митчелл:** *О ценностях в разработке ML*
+
+
+
+
+
+
+
+Маргарет Митчелл - исследователь, работающий в области этики ИИ. В настоящее время она занимается вопросами разработки ИИ с учетом этических норм в технологиях. Она опубликовала более 50 работ по генерации естественного языка, ассистивным технологиям, компьютерному зрению и этике ИИ, а также имеет множество патентов в области генерации диалогов и классификации настроений. Ранее она работала в Google AI в качестве штатного научного сотрудника, где основала и возглавила группу Google Ethical AI, которая занималась фундаментальными исследованиями в области этики ИИ и операционализацией этики ИИ внутри Google. До прихода в Google она работала исследователем в Microsoft Research, занимаясь вопросами создания компьютерного зрения и языка, а также была постдокторантом в Университете Джонса Хопкинса, занимаясь байесовским моделированием и извлечением информации. Она получила докторскую степень в области компьютерных наук в Абердинском университете и степень магистра в области вычислительной лингвистики в Вашингтонском университете. В период с 2005 по 2012 год она также работала в области машинного обучения, неврологических расстройств и вспомогательных технологий в Орегонском университете здоровья и науки. Она была инициатором ряда семинаров и инициатив на пересечении многообразия, инклюзивности, компьютерных наук и этики. Ее работа была отмечена наградами министра обороны Эша Картера и Американского фонда поддержки слепых, а также была внедрена несколькими технологическими компаниями. Она любит садоводство, собак и кошек.
+
+**Мэттью Уотсон и Чэнь Цянь:** *Рабочие процессы NLP с Keras*
+
+
+
+
+
+
+
+Мэтью Уотсон - инженер по машинному обучению в команде Keras, специализирующийся на высокоуровневых API для моделирования. Он изучал компьютерную графику в бакалавриате и получил степень магистра в Стэнфордском университете. Получив английское образование, он выбрал компьютерную науку, но очень любит работать с разными дисциплинами и делать NLP доступным для широкой аудитории.
+
+Чен Цянь - инженер-программист из команды Keras, специализирующийся на высокоуровневых API для моделирования. Чен получил степень магистра электротехники в Стэнфордском университете и особенно интересуется упрощением имплементации в коде задач ML и крупномасштабным ML проектов.
+
+**Марк Саруфим:** *Как обучить модель с помощью Pytorch*
+
+
+
+
+
+
+
+Марк Саруфим - инженер-партнер компании Pytorch, работающий над производственными инструментами OSS, включая TorchServe и Pytorch Enterprise. В прошлом Марк был прикладным ученым и менеджером по продуктам в Graphcore, [yuri.ai](http://yuri.ai/), Microsoft и NASA's JPL. Его главная страсть - сделать программирование более увлекательным.
+
+**Якоб Ушкорейт:** *Не сломалось, так не чини! Давай сломаем)*
+
+
+
+
+
+
+
+Якоб Ушкорейт - соучредитель компании Inceptive. Inceptive разрабатывает молекулы РНК для вакцин и терапевтических препаратов, используя крупномасштабное глубокое обучение в тесной связке с результативными экспериментами, с целью сделать лекарства на основе РНК более доступными, эффективными и широко применимыми. Ранее Якоб более десяти лет работал в Google, возглавляя группы исследований и разработок в Google Brain, Research and Search, работая над основами глубокого обучения, компьютерным зрением, пониманием языка и машинным переводом.
+
+## День 2: Инструменты, которые следует использовать[[day-2-the-tools-to-use]]
+
+**Льюис Танстолл:** *Простое обучение с 🤗 Transformers Trainer*
+
+
+
+Льюис - инженер по машинному обучению в компании Hugging Face, занимающейся разработкой инструментов с открытым исходным кодом и делающий их доступными для широкого круга пользователей. Он также является соавтором книги O'Reilly [Natural Language Processing with Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/). Вы можете следовать за ним в Twitter (@_lewtun) для получения советов и рекомендаций по NLP!
+
+**Мэтью Кэрриган:** *Новые функции TensorFlow для 🤗 Transformers и 🤗 Datasets*
+
+
+
+Мэтт отвечает за поддержку TensorFlow в Transformers и в конечном итоге возглавит переворот против действующей фракции PyTorch, который, вероятно, будет координироваться через его аккаунт в Twitter @carrigmat.
+
+**Лисандр Дебю:** *Hugging Face Hub как средство для совместной работы и обмена проектами по машинному обучению*
+
+
+
+
+
+
+
+Лисандр - инженер по машинному обучению в компании Hugging Face, где он участвует во многих проектах с открытым исходным кодом. Его цель - сделать машинное обучение доступным для всех, разрабатывая мощные инструменты с очень простым API.
+
+**Люсиль Сольнье:** *Получите свой собственный токенизатор с помощью 🤗 Transformers & 🤗 Tokenizers*
+
+
+
+Люсиль - инженер по машинному обучению в компании Hugging Face, занимается разработкой и поддержкой использования инструментов с открытым исходным кодом. Она также активно участвует во многих исследовательских проектах в области обработки естественного языка, таких как коллаборативное обучение и BigScience.
+
+**Сильвен Гуггер:** *Ускорьте цикл обучения PyTorch с помощью 🤗 Accelerate*
+
+
+
+Сильвен - инженер-исследователь в Hugging Face, один из основных сопровождающих 🤗 Transformers и разработчик 🤗 Accelerate. Ему нравится делать обучение моделей более доступным.
+
+**Мерве Ноян:** *Демонстрируйте свои демо моделей с помощью 🤗 Spaces*
+
+
+
+Мерве - сторонник разработчиков (developer advocate) в Hugging Face, занимается разработкой инструментов и созданием контента для них, чтобы сделать машинное обучение демократичным для всех.
+
+**Абубакар Абид:** *Быстрое создание приложений машинного обучения*
+
+
+
+
+
+
+
+Абубакар Абид - CEO компании [Gradio](www.gradio.app). В 2015 году он получил степень бакалавра наук по электротехнике и информатике в Массачусетском технологическом институте, а в 2021 году - степень доктора наук по прикладному машинному обучению в Стэнфорде. В качестве генерального директора Gradio Абубакар работает над тем, чтобы облегчить демонстрацию, отладку и развертывание моделей машинного обучения.
+
+**Матье Десве:** *AWS ML Vision: Сделать машинное обучение доступным для всех пользователей*
+
+
+
+
+
+
+
+Энтузиаст технологий, в свободное время занимаюсь творчеством. Мне нравятся задачи и решение проблем клиентов и пользователей, а также работа с талантливыми людьми, чтобы учиться каждый день. С 2004 года я работаю на разных должностях, начиная с фронтенда, бэкенда, инфраструктуры, заканчивая операциями и управлением. Стараюсь оперативно решать общие технические и управленческие вопросы.
+
+**Филипп Шмид:** *Управляемое обучение с Amazon SageMaker и 🤗 Transformers*
+
+
+
+Филипп Шмид - инженер по машинному обучению и технический руководитель в Hugging Face, где он возглавляет сотрудничество с командой Amazon SageMaker. Он увлечен демократизацией и производством передовых моделей NLP и повышением простоты использования Deep Learning.
diff --git a/chapters/ru/events/3.mdx b/chapters/ru/events/3.mdx
new file mode 100644
index 000000000..d65badcbc
--- /dev/null
+++ b/chapters/ru/events/3.mdx
@@ -0,0 +1,9 @@
+# Вечеринка Gradio Blocks[[gradio-blocks-party]]
+
+Одновременно с выпуском главы курса Gradio компания Hugging Face провела мероприятие для сообщества, посвященное созданию крутых демо машинного обучения с помощью новой функции Gradio Blocks.
+
+Все демо, созданные сообществом, вы можете найти в организации [`Gradio-Blocks`](https://huggingface.co/Gradio-Blocks) на Hub. Вот несколько примеров от победителей:
+
+**Преобразование естественного языка в SQL**
+
+
diff --git a/requirements.txt b/requirements.txt
index 8f94be377..0a14ffdfa 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,3 @@
nbformat>=5.1.3
PyYAML>=5.4.1
-black==22.3.0
\ No newline at end of file
+black>=24.1.1
\ No newline at end of file
+
+
+
+
+
+
+
+
+
+
+