FRED-T5-large-instruct-v0.1

Model was trained by bond005 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).
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

You can view the code example describing the use of this model to solve all the above tasks in the corresponding Colab notebook.

ASR Correction

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)

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

Summarization

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)

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

Segmentation

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')

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


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


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


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

Simplification

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)

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

Named Entity Recognition (NER)

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}')

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

С. Ситников

Костромы

Answering arbitrary questions

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')

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

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

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.