Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

Укажи на отличия между скриптами: Первый: !pip install datasets !pip install…

  1. User

    Укажи на отличия между скриптами: Первый: !pip install datasets !pip install transformers !pip install evaluate

    from typing import List, Tuple from datasets import load_dataset, Dataset import evaluate import numpy as np from sklearn.metrics import classification_report import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification from transformers import DataCollatorWithPadding from transformers import TrainingArguments, Trainer from transformers import pipeline

    MODEL_NAME = 'DeepPavlov/rubert-base-cased' tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

    DATASET_NAME = 'Davlan/sib200' DATASET_LANGUAGE = 'rus_Cyrl' train_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='train') validation_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='validation') test_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='test')

    print(train_set)

    MINIBATCH_SIZE = 64 tokenized_train_set = train_set.map( lambda it: tokenizer(it['text'], truncation=True), batched=True, batch_size=MINIBATCH_SIZE ) tokenized_validation_set = validation_set.map( lambda it: tokenizer(it['text'], truncation=True), batched=True, batch_size=MINIBATCH_SIZE )

    print(tokenized_train_set)

    cls_metric = evaluate.load('f1')

    def compute_metrics(eval_pred): predictions, labels = eval_pred predictions = np.argmax(predictions, axis=1) return cls_metric.compute(predictions=predictions, references=labels, average='macro')

    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

    list_of_categories = sorted(list( set(train_set['category']) | set(validation_set['category']) | set(test_set['category']) )) indices_of_categories = list(range(len(list_of_categories))) n_categories = len(list_of_categories) print(f'Categories for classification are: {list_of_categories}') id2label = dict(zip(indices_of_categories, list_of_categories)) label2id = dict(zip(list_of_categories, indices_of_categories))

    labeled_train_set = tokenized_train_set.add_column( 'label', [label2id[val] for val in tokenized_train_set['category']] ) labeled_validation_set = tokenized_validation_set.add_column( 'label', [label2id[val] for val in tokenized_validation_set['category']] )

    print(labeled_train_set)

    classifier = AutoModelForSequenceClassification.from_pretrained( MODEL_NAME, num_labels=n_categories, id2label=id2label, label2id=label2id ).cuda() for param in classifier.parameters(): param.data = param.data.contiguous()

    training_args = TrainingArguments( output_dir='rubert_sib200', learning_rate=2e-5, per_device_train_batch_size=MINIBATCH_SIZE, per_device_eval_batch_size=MINIBATCH_SIZE, num_train_epochs=20, weight_decay=1e-3, eval_strategy='epoch', save_strategy='epoch', load_best_model_at_end=True )

    trainer = Trainer( model=classifier, args=training_args, train_dataset=labeled_train_set, eval_dataset=labeled_validation_set, tokenizer=tokenizer, data_collator=data_collator, compute_metrics=compute_metrics, )

    trainer.train()

    classifiсation_pipeline = pipeline('text-classification', model=classifier, tokenizer=tokenizer, device=0)

    y_pred = list(map(lambda x: x['label'], classifiсation_pipeline(validation_set['text']))) y_true = validation_set['category'] print(classification_report(y_true=y_true, y_pred=y_pred))

    y_pred = list(map(lambda x: x['label'], classifiсation_pipeline(test_set['text']))) y_true = test_set['category'] print(classification_report(y_true=y_true, y_pred=y_pred)) Второй: from typing import List, Tuple from datasets import load_dataset, Dataset import evaluate import numpy as np from sklearn.metrics import classification_report import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification from transformers import DataCollatorWithPadding from transformers import TrainingArguments, Trainer from transformers import pipeline

    Define model name for classification

    MODEL_NAME = 'cointegrated/rubert-tiny' # smaller, faster version of RuBERT tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) # for inputs preprocessing

    DATASET_NAME = 'Davlan/sib200' DATASET_LANGUAGE = 'rus_Cyrl' train_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='train') validation_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='validation') test_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='test')

    Define minibatch size and tokenize datasets

    MINIBATCH_SIZE = 64 # batching helps in efficiently processing multiple examples at once allowing parallel computation

    converting text to tokens

    tokenized_train_set = train_set.map( lambda it: tokenizer(it['text'], truncation=True), batched=True, batch_size=MINIBATCH_SIZE ) tokenized_validation_set = validation_set.map( lambda it: tokenizer(it['text'], truncation=True), batched=True, batch_size=MINIBATCH_SIZE )

    cls_metric = evaluate.load('f1') # for evaluating the performance of the classification model

    Define a function to compute performance metrics during evaluation

    It transforms logits to predicted labels and calculates the F1 score, which is

    the harmonic mean of precision and recall providing a balance of both

    def compute_metrics(eval_pred): predictions, labels = eval_pred predictions = np.argmax(predictions, axis=1) return cls_metric.compute(predictions=predictions, references=labels, average='macro')

    Instantiate a data collator that dynamically pads batch elements to the same length

    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

    Gather and sort the possible categories in the dataset for classification labels

    This step is essential to map string labels to numerical IDs needed by the model

    list_of_categories = sorted(list( set(train_set['category']) | set(validation_set['category']) | set(test_set['category']) )) indices_of_categories = list(range(len(list_of_categories))) n_categories = len(list_of_categories) print(f'Categories for classification are: {list_of_categories}') # Log the categories

    Create mappings between labels and numerical IDs used by the classifier

    id2label = dict(zip(indices_of_categories, list_of_categories)) label2id = dict(zip(list_of_categories, indices_of_categories))

    Add a numeric label column to train and validation datasets using the created mappings

    These labels will be used during the training process

    labeled_train_set = tokenized_train_set.add_column( 'label', [label2id[val] for val in tokenized_train_set['category']] ) labeled_validation_set = tokenized_validation_set.add_column( 'label', [label2id[val] for val in tokenized_validation_set['category']] )

    Load the pre-trained model for sequence classification and configure it for our specific number of categories

    classifier = AutoModelForSequenceClassification.from_pretrained( MODEL_NAME, num_labels=n_categories, id2label=id2label, label2id=label2id ) for param in classifier.parameters(): param.data = param.data.contiguous()

    training_args = TrainingArguments( output_dir='rubert_sib200', # Directory to save the model's output learning_rate=3e-5, # Learning rate controls how much to adjust the model's weights during training; experimentation can identify optimal values per_device_train_batch_size=32, # Number of training examples processed together in a single update; larger batches may use more effective parallelism per_device_eval_batch_size=32, # Similar batch size for evaluation num_train_epochs=25, # Number of times the model will be trained on the entire training set; more epochs can improve or overfit the model weight_decay=0.01, # Regularization parameter to prevent overfitting by penalizing large weights eval_strategy='epoch', # Evaluate the model performance at the end of each epoch save_strategy='epoch', # Save the model at the end of each epoch for potential restoration load_best_model_at_end=True # Restore the best performing model at the end of training for final testing )

    trainer = Trainer( model=classifier, args=training_args, train_dataset=labeled_train_set, eval_dataset=labeled_validation_set, tokenizer=tokenizer, data_collator=data_collator, compute_metrics=compute_metrics, )

    trainer.train()

    classifiсation_pipeline = pipeline('text-classification', model=classifier, tokenizer=tokenizer, device=-1)

    Predict the categories for the validation set texts and generate a classification report

    The report includes precision, recall, F1-score, and support for each class

    y_pred = list(map(lambda x: x['label'], classifiсation_pipeline(validation_set['text']))) y_true = validation_set['category'] print(classification_report(y_true=y_true, y_pred=y_pred))

    Similarly, predict the categories for the test set texts and generate a classification report

    y_pred = list(map(lambda x: x['label'], classifiсation_pipeline(test_set['text']))) y_true = test_set['category'] print(classification_report(y_true=y_true, y_pred=y_pred))

  2. Assistant

    Сравним два скрипта, указав на их отличия:

    1. Модель:

      • Первый скрипт: Использует модель DeepPavlov/rubert-base-cased.
      • Второй скрипт: Использует модель cointegrated/rubert-tiny, что представляет собой более маленькую и быструю версию RuBERT.
    2. Настройки обучения:

      • Первый скрипт:
        • Скорость обучения (learning_rate) установлена на 2e-5.
        • Размер мини-пакета (per_device_train_batch_size и per_device_eval_batch_size) составляет 64.
        • Число эпох (num_train_epochs) равно 20.
        • Коэффициент регуляризации (weight_decay) составляет 1e-3.
      • Второй скрипт:
        • Скорость обучения (learning_rate) установлена на 3e-5.
        • Размер мини-пакета (per_device_train_batch_size и per_device_eval_batch_size) равен 32.
        • Число эпох (num_train_epochs) равно 25.
        • Коэффициент регуляризации (weight_decay) составляет 0.01.
    3. Использование устройства:

      • Первый скрипт: Передает модель на GPU (.cuda()) и использует device=0 в классификационном пайплайне.
      • Второй скрипт: Не осуществляет явной передачи модели на GPU и использует device=-1, что обычно означает использование CPU.
    4. Импорты библиотек:

      • Первый скрипт: Устанавливает необходимые пакеты с помощью !pip install datasets, !pip install transformers, !pip install evaluate, что может указывать на запуск в интерактивной среде (например, Jupyter Notebook). Эти команды отсутствуют во втором скрипте.

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

  3. User

    А здесь? Первая:

    Импортирование необходимых библиотек

    import random from typing import Dict, List, Union

    from datasets import load_dataset from fuzzywuzzy import fuzz, process from sklearn.metrics import classification_report from tqdm.notebook import tqdm from transformers import pipeline import torch

    Ваша функция для подготовки сообщений осталась без изменений

    def prepare_message_for_llm(text: Union[str, List[str]], categories: Dict[str, str]) -> Dict[str, Union[List[Dict[str, str]], List[List[Dict[str, str]]]]]: if len(categories) < 2: raise RuntimeError(f'The category list is too small! Expected 2 or more categories, got {len(categories)} ones.') categories_ = sorted(list(categories.keys())) categories_as_string = ', '.join(categories_[:-1]) + ' и ' + categories_[-1] if isinstance(text, str): prompt = f'Прочтите, пожалуйста, следующий текст и определите, какая тема из известного '
    f'списка тем наиболее представлена в следующем тексте. '
    f'В качестве ответа напишите только название темы из списка, больше ничего.\n'
    f'Список тем: {categories_as_string}.\n' for cur in categories_: prompt += f'Текст: {" ".join(categories[cur].split())}\nВаш ответ: {cur}\n' prompt += f'Текст: {" ".join(text.split())}\nВаш ответ: ' messages = [ { 'role': 'system', 'content': 'Вы - полезный помощник, умеющий читать тексты на русском языке, глубоко понимать их и анализировать.' }, { 'role': 'user', 'content': prompt } ] else: messages = [] for it in text: prompt = f'Прочтите, пожалуйста, следующий текст и определите, какая тема из известного '
    f'списка тем наиболее представлена в следующем тексте. '
    f'В качестве ответа напишите только название темы из списка, больше ничего.\n'
    f'Список тем: {categories_as_string}.\n' for cur in categories_: prompt += f'Текст: {" ".join(categories[cur].split())}\nВаш ответ: {cur}\n' prompt += f'Текст: {" ".join(text.split())}\nВаш ответ: ' messages.append([ { 'role': 'system', 'content': 'Вы - полезный помощник, умеющий читать тексты на русском языке, глубоко понимать их и анализировать.' }, { 'role': 'user', 'content': prompt } ]) return {'message_for_llm': messages}

    Инициализация pipeline для zero-shot классификации

    llm_pipeline = pipeline( 'zero-shot-classification', model='distilbert-base-multilingual-cased', # Multilingual поддерживает русский язык device=0 if torch.cuda.is_available() else -1 # Использовать GPU, если доступен )

    Загрузка данных

    DATASET_NAME = 'Davlan/sib200' DATASET_LANGUAGE = 'rus_Cyrl' train_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='train') validation_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='validation') test_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='test')

    Определение категорий

    list_of_categories = sorted(list( set(train_set['category']) | set(validation_set['category']) | set(test_set['category']) )) print(f'Categories for classification are: {list_of_categories}')

    Подготовка примеров для каждой категории

    examples_by_categories = {} for current_category in list_of_categories: examples_by_categories[current_category] = random.choice( train_set.filter(lambda it: it['category'] == current_category)['text'] )

    Подготовка данных для LLM

    validation_set_for_llm = validation_set.map(lambda it: prepare_message_for_llm(it['text'], examples_by_categories)) test_set_for_llm = test_set.map(lambda it: prepare_message_for_llm(it['text'], examples_by_categories))

    Уменьшение размера выборки

    sample_size = 10 # Пример: используем 10 примеров validation_sample = validation_set_for_llm.select(range(sample_size))

    Генерация предсказаний

    y_pred = list(map( lambda messages: llm_pipeline( messages[1]['content'], # Доступ к содержимому текста сообщения candidate_labels=list_of_categories, hypothesis_template="Этот текст связан с категорией {}." )['labels'][0], # Получение первой прогнозируемой метки tqdm(validation_sample['message_for_llm']) ))

    Истинные метки

    y_true = validation_set.select(range(sample_size))['category']

    Печать отчета о классификации

    print(classification_report(y_true=y_true, y_pred=y_pred))

    Вторая: llm_pipeline = pipeline( 'zero-shot-classification', model='distilbert-base-multilingual-cased',
    device=0 if torch.cuda.is_available() else -1 # GPU )

    DATASET_NAME = 'Davlan/sib200' DATASET_LANGUAGE = 'rus_Cyrl' train_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='train') validation_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='validation') test_set = load_dataset(DATASET_NAME, DATASET_LANGUAGE, split='test')

    list_of_categories = sorted(list( set(train_set['category']) | set(validation_set['category']) | set(test_set['category']) )) print(f'Categories for classification are: {list_of_categories}')

    examples_by_categories = {} for current_category in list_of_categories: filtered_texts = train_set.filter(lambda it: it['category'] == current_category)['text'] examples_by_categories[current_category] = ' '.join(filtered_texts[:3])

    validation_set_for_llm = validation_set.map(lambda it: prepare_message_for_llm(it['text'], examples_by_categories)) test_set_for_llm = test_set.map(lambda it: prepare_message_for_llm(it['text'], examples_by_categories))

    sample_size = 10
    validation_sample = validation_set_for_llm.select(range(sample_size))

    y_pred = list(map( lambda messages: llm_pipeline( messages[1]['content'],
    candidate_labels=list_of_categories, hypothesis_template="Этот текст более всего относится к категории {}."
    )['labels'][0],
    tqdm(validation_sample['message_for_llm']) ))

    y_true = validation_set.select(range(sample_size))['category']

    print(classification_report(y_true=y_true, y_pred=y_pred))

  4. Assistant

    Отличия между двумя скриптами заключаются в следующем:

    1. Импорты и исходные настройки:

      • Первая версия скрипта: Импортируется больше зависимостей, включая random, fuzzywuzzy, и torch. Кроме того, определена функция prepare_message_for_llm, которая строит сообщения для модели на основе входных текстов и категорий.
      • Вторая версия скрипта: Содержит меньше импортов и не имеет определенной функции для подготовки сообщений.
    2. Подготовка данных:

      • Первая версия: Для каждой категории выбирается случайный пример из тренировочного набора через функцию random.choice. Функция prepare_message_for_llm используется для создания сообщений с примерами для каждой категории.
      • Вторая версия: Вместо одного примера, для каждой категории берутся первые три текста, объединяются в один текст, и это значение сохраняется в examples_by_categories.
    3. Шаблон гипотезы для классификации:

      • Первая версия: Используется строка "Этот текст связан с категорией {}." как шаблон гипотезы для классификации.
      • Вторая версия: Используется шаблон "Этот текст более всего относится к категории {}."
    4. Комментирование и объяснения:

      • В первой версии: Имеется больше комментариев, которые объясняют шаги кода и цели различных частей кода, что делает скрипт более информативным.

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