transformers pytorch safetensors t5 text2text-generation PyTorch Transformers ru license:apache-2.0 autotrain_compatible text-generation-inference endpoints_compatible region:us
---
language: ru
license: apache-2.0
tags:
- PyTorch
- Transformers
widget:
- text: Исправь, пожалуйста, ошибки распознавания речи в следующем тексте. краеугольным
    камнем любышь алгоритных машиного обучения является преждес его обобщающая способности
    тогда мы обучаем некоторую модель у нас есть обучающая выборка унаситькюмся ошибки
    и наша задачи сводится вообщем такомптиминационной задачи мы минимизируем в функцию
    ошибки по параметрам нашей модели на обучающие выбрать но на самом деле хотим
    там и не этого мы не обучающую ошибку хотим минимизировать
- text: Упрости, пожалуйста, следующий текст. Краеугольным камнем любых алгоритмов
    машинного обучения является, прежде всего, обобщающая способность. Когда мы обучаем
    некоторую модель, у нас есть обучающая выборка, у нас есть функция ошибки, и наша
    задача сводится, в общем-то, к оптимизационной задаче. Мы минимизируем функцию
    ошибки по параметрам нашей модели на обучающей выборке. Но на самом деле хотим-то
    мы не этого! Мы не обучающую ошибку хотим минимизировать.
- text: Выполни саммаризацию и выдели, пожалуйста, основную мысль следующего текста.
    В данной работе проводится сравнение предварительного обучения трансформера на
    текстах естественного языка и на предложениях синтетического псевдоязыка. Искусственные
    тексты были автоматически сгенерированы по написанным нами правилам в контекстно-свободной
    грамматике. Результаты дообучения на выполнение заданий проекта RussianSuperGLUE
    статистически достоверно показали, что модели имеют одинаковые оценки, т.е. можно
    считать, что использование искусственных данных дает преимущество для “безопасности”
    искусственного интеллекта за счет возможности полностью контролировать состав
    выборки. Также мы можем говорить о том, что на этапе предобучения модели типа
    RoBERTa достаточно научиться распознавать только синтаксические и морфологические
    закономерности языка, которые могут быть успешно созданы довольно таким простым
    способом, как контекстно-свободная грамматика.
- text: Найди, пожалуйста, все именованные сущности типа "Местоположение" в следующем
    тексте и выпиши список таких сущностей. С. Ситников - уроженец Костромы, пользуется
    популярностью в области.
- text: Найди, пожалуйста, все именованные сущности типа "Человек" в следующем тексте
    и выпиши список таких сущностей. С. Ситников - уроженец Костромы, пользуется популярностью
    в области.
- text: Найди, пожалуйста, все именованные сущности типа "Организация" в следующем
    тексте и выпиши список таких сущностей. Окончил Костромской государственный педагогический
    институт по специальности "учитель истории и обществоведения, методист воспитательной
    работы".
- text: Опишите процесс фотосинтеза.
- text: 'Дополни предложение правильной формой глагола: "Я ... (писать) письмо уже
    час."'
---

# FRED-T5-large-instruct-v0.1

Model was trained by [bond005](https://scholar.google.ru/citations?user=3AJKH38AAAAJ)  for automatically editing text and generating answers to various questions in Russian. The solved tasks are:

1. **asr_correction** This task is to correct errors, restore punctuation and capitalization in the ASR output (in particular, output of [Wav2Vec2-Large-Ru-Golos](https://huggingface.co/bond005/wav2vec2-large-ru-golos)).
2. **summarization** This is an abstractive summarization of long texts.
3. **segmentation** The purpose of this task is to divide long text into paragraphs by the `\n` character as a special separator.
4. **simplification** This task is to transform a source sentence to become easier to read and comprehend.
5. **ner_organization** This is variant of the "classical" named entity recognition task, designed to find and print all organizations in the text. Each organization is printed from a new line.
6. **ner_person** This is variant of the "classical" named entity recognition task, designed to find and print all persons in the text. Each person is printed from a new line.
7. **ner_location** This is variant of the "classical" named entity recognition task, designed to find and print all locations in the text. Each location is printed from a new line.
8. Answering arbitrary questions and completing various instructions.

## Usage

| The solved task        | The instruction text (in Russian)                                                                                         |
|------------------------|---------------------------------------------------------------------------------------------------------------------------|
|  asr_correction        | Исправь, пожалуйста, ошибки распознавания речи в следующем тексте.                                                    |
|  summarization         | Выполни саммаризацию и выдели, пожалуйста, основную мысль следующего текста.                                          |
|  segmentation          | Разбей, пожалуйста, следующий текст на абзацы.                                                                        |
|  simplification        | Упрости, пожалуйста, следующий текст.                                                                                 |
|  ner_person            | Найди, пожалуйста, все именованные сущности типа "Человек" в следующем тексте и выпиши список таких сущностей.        |
|  ner_location          | Найди, пожалуйста, все именованные сущности типа "Местоположение" в следующем тексте и выпиши список таких сущностей. |
|  ner_organization      | Найди, пожалуйста, все именованные сущности типа "Организация" в следующем тексте и выпиши список таких сущностей.    |
|  *arbitrary questions* | *text of any question*                                                                                                |

You can view the code example describing the use of this model to solve all the above tasks in the corresponding [Colab notebook](https://colab.research.google.com/drive/10vX4aLm4-qllksTBEiyifgp0RFbgWxuq?usp=sharing).

### ASR Correction

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch


def fix_recognition_error(texts: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                          model: T5ForConditionalGeneration) -> List[str]:
    nonempty_texts = []
    for cur in texts:
        if len(cur.strip()) > 3:
            nonempty_texts.append(cur.strip())
    if len(nonempty_texts) == 0:
        return texts
    x = tokenizer(nonempty_texts, return_tensors='pt', padding=True).to(model.device)
    max_size = int(x.input_ids.shape[1] * 2.0 + 10)
    out = model.generate(**x, generation_config=config, max_length=max_size)
    results_for_nonempty_texts = [
        ' '.join(tokenizer.decode(cur, skip_special_tokens=True).strip().split()) for cur in out
    ]
    united_results = []
    idx = 0
    for cur in texts:
        if len(cur.strip()) > 3:
            united_results.append(results_for_nonempty_texts[idx])
            idx += 1
        else:
            united_results.append(cur.strip())
    return united_results


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

asr_correction_example = \
    'Исправь, пожалуйста, ошибки распознавания речи в следующем тексте. ' \
    'краеугольным камнем любышь алгоритных машиного обучения является преждес его ' \
    'обобщающая способности тогда мы обучаем некоторую модель у нас есть обучающая ' \
    'выборка унаситькюмся ошибки и наша задачи сводится вообщем такомптиминационной ' \
    'задачи мы минимизируем в функцию ошибки по параметрам нашей модели на обучающие ' \
    'выбрать но на самом деле хотим там и не этого мы не обучающую ошибку хотим ' \
    'минимизировать'

output = fix_recognition_error([asr_correction_example], ru_llm_tokenizer,
                               ru_llm_config, ru_llm_model)[0]
print(output)
```

```text
Краеугольным камнем любого алгоритма машинного обучения является прежде всего обобщающая способность. Тогда мы обучаем некоторую модель, у нас есть обучающая выборка, у нас есть коэффициенты ошибки, и наша задача сводится, в общем-то, к мотивационной задаче: мы минимизируем функцию ошибки по параметрам нашей модели, на обучающей выборке, но на самом деле хотим там и не этого. Мы не обучающую ошибку хотим минимизировать.
```

### Summarization

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch

def generate_answer(answers: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                    model: T5ForConditionalGeneration) -> List[str]:
    nonempty_answers = []
    for cur in answers:
        if len(cur.strip()) > 0:
            nonempty_answers.append(cur)
    if len(nonempty_answers) == 0:
        return ['' for _ in range(len(answers))]
    x = tokenizer(nonempty_answers, return_tensors='pt', padding=True).to(model.device)
    out = model.generate(**x, generation_config=config)
    questions_for_nonempty_texts = [
        tokenizer.decode(cur, skip_special_tokens=True).strip().replace('\r\n', '\n') for cur in out
    ]
    united_questions = []
    idx = 0
    for cur in answers:
        if len(cur.strip()) > 0:
            united_questions.append(questions_for_nonempty_texts[idx])
            idx += 1
        else:
            united_questions.append('')
    return united_questions


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

summarization_example = \
    'Выполни саммаризацию и выдели, пожалуйста, основную мысль следующего текста. ' \
    'В данной работе проводится сравнение предварительного обучения трансформера на ' \
    'текстах естественного языка и на предложениях синтетического псевдоязыка. ' \
    'Искусственные тексты были автоматически сгенерированы по написанным нами правилам ' \
    'в контекстно-свободной грамматике. Результаты дообучения на выполнение заданий ' \
    'проекта RussianSuperGLUE статистически достоверно показали, что модели имеют ' \
    'одинаковые оценки, т.е. можно считать, что использование искусственных данных ' \
    'дает преимущество для “безопасности” искусственного интеллекта за счет ' \
    'возможности полностью контролировать состав выборки. Также мы можем говорить ' \
    'о том, что на этапе предобучения модели типа RoBERTa достаточно научиться ' \
    'распознавать только синтаксические и морфологические закономерности языка, ' \
    'которые могут быть успешно созданы довольно таким простым способом, как ' \
    'контекстно-свободная грамматика.'

output = generate_answer([summarization_example], ru_llm_tokenizer,
                         ru_llm_config, ru_llm_model)[0]
print(output)
```

```text
В работе сравнивается предварительное обучение трансформера на текстах естественного языка и на предложениях синтетического псевдоязыка. Результаты дообучения на выполнение заданий проекта RussianSuperGLUE статистически достоверно показали, что модели имеют одинаковые оценки. Использование искусственных данных дает преимущество для безопасности искусственного интеллекта за счет возможности полностью контролировать состав выборки.
```

### Segmentation

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch

def generate_answer(answers: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                    model: T5ForConditionalGeneration) -> List[str]:
    nonempty_answers = []
    for cur in answers:
        if len(cur.strip()) > 0:
            nonempty_answers.append(cur)
    if len(nonempty_answers) == 0:
        return ['' for _ in range(len(answers))]
    x = tokenizer(nonempty_answers, return_tensors='pt', padding=True).to(model.device)
    out = model.generate(**x, generation_config=config)
    questions_for_nonempty_texts = [
        tokenizer.decode(cur, skip_special_tokens=True).strip().replace('\r\n', '\n') for cur in out
    ]
    united_questions = []
    idx = 0
    for cur in answers:
        if len(cur.strip()) > 0:
            united_questions.append(questions_for_nonempty_texts[idx])
            idx += 1
        else:
            united_questions.append('')
    return united_questions


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

segmentation_example = \
    'Разбей, пожалуйста, следующий текст на абзацы. Глубокие нейронные сети за ' \
    'последнее время стали наиболее популярным инструментом для решения большинства ' \
    'задач искусственного интеллекта и особенно задач анализа и генерации текстов на ' \
    'естественном языке, относящихся к т.н. “разговорному искусственному интеллекту”. ' \
    'Это произошло по двум причинам: 1. Нейронная сеть строит обучаемую иерархию ' \
    'представлений. 2. Эта иерархия представлений является переиспользуемой между ' \
    'задачами, на чем основана известная техника переноса обучения, когда нейросетевая ' \
    'модель предварительно обучается (предобучается) на большой обучающей выборке ' \
    'решать ненужную задачу, для которой доступна “дешевая” или автоматическая ' \
    'разметка, а потом дообучается на малой обучающей выборке, описывающей конечную ' \
    'задачу и размеченной вручную. При этом глубокие нейронные сети, как и другие ' \
    'методы машинного обучения, могут быть неустойчивы к ряду уязвимостей и угроз, что ' \
    'создает препятствия при создании доверительного искусственного интеллекта на ' \
    'базе нейросетевого подхода.'

output = generate_answer([segmentation_example], ru_llm_tokenizer,
                         ru_llm_config, ru_llm_model)[0]
for it in output.split('\n'):
    print(f'\n{it}\n')
```

```text
Глубокие нейронные сети за последнее время стали наиболее популярным инструментом для решения большинства задач искусственного интеллекта и особенно задач анализа и генерации текстов на естественном языке, относящихся к т.н. “разговорному искусственному интеллекту”. Это произошло по двум причинам:


1. Нейронная сеть строит обучаемую иерархию представлений.


2. Эта иерархия представлений является переиспользуемой между задачами, на чем основана известная техника переноса обучения, когда нейросетевая модель предварительно обучается (предобучается) на большой обучающей выборке решать ненужную задачу, для которой доступна “дешевая” или автоматическая разметка, а потом дообучается на малой обучающей выборке, описывающей конечную задачу и размеченной вручную.


При этом глубокие нейронные сети, как и другие методы машинного обучения, могут быть неустойчивы к ряду уязвимостей и угроз, что создает препятствия при создании доверительного искусственного интеллекта на базе нейросетевого подхода.


```

### Simplification

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch

def generate_answer(answers: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                    model: T5ForConditionalGeneration) -> List[str]:
    nonempty_answers = []
    for cur in answers:
        if len(cur.strip()) > 0:
            nonempty_answers.append(cur)
    if len(nonempty_answers) == 0:
        return ['' for _ in range(len(answers))]
    x = tokenizer(nonempty_answers, return_tensors='pt', padding=True).to(model.device)
    out = model.generate(**x, generation_config=config)
    questions_for_nonempty_texts = [
        tokenizer.decode(cur, skip_special_tokens=True).strip().replace('\r\n', '\n') for cur in out
    ]
    united_questions = []
    idx = 0
    for cur in answers:
        if len(cur.strip()) > 0:
            united_questions.append(questions_for_nonempty_texts[idx])
            idx += 1
        else:
            united_questions.append('')
    return united_questions


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

simplification_example = \
    'Упрости, пожалуйста, следующий текст. ' \
    'Краеугольным камнем любых алгоритмов машинного обучения является, прежде всего, ' \
    'обобщающая способность. Когда мы обучаем некоторую модель, у нас есть обучающая ' \
    'выборка, у нас есть функция ошибки, и наша задача сводится, в общем-то, ' \
    'к оптимизационной задаче. Мы минимизируем функцию ошибки по параметрам нашей ' \
    'модели на обучающей выборке. Но на самом деле хотим-то мы не этого! ' \
    'Мы не обучающую ошибку хотим минимизировать.'

output = generate_answer([summarization_example], ru_llm_tokenizer,
                         ru_llm_config, ru_llm_model)[0]
print(output)
```

```text
Алгоритмы машинного обучения должны учитывать обобщающую способность, а не только функцию ошибки. При обучении модели мы минимизируем функцию ошибки, но не обучающую ошибку.
```

### Named Entity Recognition (NER)

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch

def generate_answer(answers: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                    model: T5ForConditionalGeneration) -> List[str]:
    nonempty_answers = []
    for cur in answers:
        if len(cur.strip()) > 0:
            nonempty_answers.append(cur)
    if len(nonempty_answers) == 0:
        return ['' for _ in range(len(answers))]
    x = tokenizer(nonempty_answers, return_tensors='pt', padding=True).to(model.device)
    out = model.generate(**x, generation_config=config)
    questions_for_nonempty_texts = [
        tokenizer.decode(cur, skip_special_tokens=True).strip().replace('\r\n', '\n') for cur in out
    ]
    united_questions = []
    idx = 0
    for cur in answers:
        if len(cur.strip()) > 0:
            united_questions.append(questions_for_nonempty_texts[idx])
            idx += 1
        else:
            united_questions.append('')
    return united_questions


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

ner_examples = [
    'Найди, пожалуйста, все именованные сущности типа "Организация" в следующем ' \
    'тексте и выпиши список таких сущностей. Окончил Костромской государственный ' \
    'педагогический институт по специальности "учитель истории и обществоведения, ' \
    'методист воспитательной работы".',  # organization
    'Найди, пожалуйста, все именованные сущности типа "Человек" в следующем тексте ' \
    'и выпиши список таких сущностей. С. Ситников - уроженец Костромы, пользуется ' \
    'популярностью в области.',  # person
    'Найди, пожалуйста, все именованные сущности типа "Местоположение" в следующем ' \
    'тексте и выпиши список таких сущностей. С. Ситников - уроженец Костромы, ' \
    'пользуется популярностью в области.',  # location
]

outputs = generate_answer(ner_examples, ru_llm_tokenizer, ru_llm_config, ru_llm_model)
for it in outputs:
    print(f'\n{it}')
```

```text

Костромской государственный педагогический институт

С. Ситников

Костромы
```

### Answering arbitrary questions

```python
from typing import List

from transformers import T5ForConditionalGeneration
from transformers import GenerationConfig
from transformers import GPT2Tokenizer
import torch

def generate_answer(answers: List[str], tokenizer: GPT2Tokenizer, config: GenerationConfig,
                    model: T5ForConditionalGeneration) -> List[str]:
    nonempty_answers = []
    for cur in answers:
        if len(cur.strip()) > 0:
            nonempty_answers.append(cur)
    if len(nonempty_answers) == 0:
        return ['' for _ in range(len(answers))]
    x = tokenizer(nonempty_answers, return_tensors='pt', padding=True).to(model.device)
    out = model.generate(**x, generation_config=config)
    questions_for_nonempty_texts = [
        tokenizer.decode(cur, skip_special_tokens=True).strip().replace('\r\n', '\n') for cur in out
    ]
    united_questions = []
    idx = 0
    for cur in answers:
        if len(cur.strip()) > 0:
            united_questions.append(questions_for_nonempty_texts[idx])
            idx += 1
        else:
            united_questions.append('')
    return united_questions


ru_llm_tokenizer = GPT2Tokenizer.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_model = T5ForConditionalGeneration.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
ru_llm_config = GenerationConfig.from_pretrained('bond005/FRED-T5-large-instruct-v0.1')
if torch.cuda.is_available():
    ru_llm_model = ru_llm_model.cuda()

question_about_scientific_facts = 'Опишите процесс фотосинтеза.'
output = generate_answer([question_about_scientific_facts], ru_llm_tokenizer,
                         ru_llm_config, ru_llm_model)[0]
print(f'Вопрос: {question_about_scientific_facts[4:]}')
print(f'Ответ:  {output}\n')

question_about_russian_grammar = 'Дополни предложение правильной формой глагола: ' \
                                 '"Я ... (писать) письмо уже час."'
output = generate_answer([question_about_russian_grammar], ru_llm_tokenizer,
                         ru_llm_config, ru_llm_model)[0]
print(f'Вопрос: {question_about_russian_grammar[4:]}')
print(f'Ответ:  {output}\n')
```

```text
Опишите процесс фотосинтеза.
Фотосинтез - это процесс, в котором растения используют энергию света для преобразования углекислого газа и воды в глюкозу и кислород. Во время фотосинтеза светосинтетические органеллы растительной клетки - хлоропласты - преобразуют световую энергию в химическую, которая затем используется для синтеза глюкозы и других органических соединений.

Дополни предложение правильной формой глагола: "Я ... (писать) письмо уже час."
Я пишу письмо уже час.

```

## Limitations of FRED-T5-large-instruct-v0.1

Generate Inaccurate Code and Facts: The model may produce incorrect code snippets and statements. Users should treat these outputs as suggestions or starting points, not as definitive or accurate solutions.

Language Limitations: The model is primarily designed to understand standard Russian. Informal Russian, slang, or any other languages might pose challenges to its comprehension, leading to potential misinterpretations or errors in response.

Potential Societal Biases: FRED-T5-large-instruct-v0.1 is not entirely free from societal biases despite efforts in assuring training data safety. There's a possibility it may generate content that mirrors these societal biases, particularly if prompted or instructed to do so. I urge users to be aware of this and to exercise caution and critical thinking when interpreting model outputs.

Toxicity: The model can still produce harmful content if explicitly prompted or instructed to do so.
