Физтех.Статистика

Скачать ipynb

Введение в анализ данных

Применение различных нейросетевых моделей

Ранее мы рассмотрели базовые примеры работы с библиотекой PyTorch. В этом ноутбуке представлены варианты решения различных практических задач с помощью нейронных сетей. Посмотрев этот ноутбук, вы не научитесь решать данные задачи. Главная цель — познакомить вас с различными областями применения нейронных сетей и показать как интересен мир :)

В этом ноутбуке рассматривается только применение различных нейросетевых моделей, обучение моделей не показано. Здесь используются уже кем-то обученные модели, для чего загружаются параметры моделей явным или неявным образом. Если хотите научиться обучать модели, приходите на факультативную часть по CV и NLP!

Чтобы все корректно отработало, этот ноутбук нужно запускать в той среде, где есть графический процессор (GPU = Graphics processing unit) от Nvidia. Графические процессоры позволяют ускорять матричные вычисления, которые постоянно производятся во время обучения и применения нейронных сетей. Необходимость использования GPU исключительно от Nvidia заключается в том, что PyTorch производит операции на GPU благодаря библиотеке CUDA, которая написана также компанией Nvidia для своих графических процессоров.

Примером среды, где вы можете бесплатно воспользоваться GPU, служит Google Colab. Однако учтите, что на данный момент доступ к GPU ограничен работой в несколько часов в сутки. Для того, чтобы подключиться GPU, зайдите в меню Среда выполнения, выберите опцию Cменить среду выполнения. В списке аппаратных ускорителей выберите GPU.

# !pip install -q 'git+https://github.com/facebookresearch/detectron2.git'

import numpy as np
import requests

import cv2
import matplotlib.pyplot as plt
from PIL import Image

1. Определение объектов на изображении

Наша задача — для заданных категорий объектов, например, человек, сумка и т.д., определить их местоположение на изображении, если они на нем есть, а также выделить области соответствующих объектов на картинке и назвать категории выделенных объектов. В области компьютерного зрения эта задача имеет свое название — объектная сегментация / instance segmentation.

Для решения задачи объектной сегментации будем пользоваться библиотекой Detectron2. Она удобна тем, что нужно приложить совсем немного усилий, чтобы решить поставленную задачу.

from detectron2 import model_zoo
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog

Отобразим изображение, с которым будем работать.

# ссылка на изображение
url = 'https://miptstats.github.io/courses/ad_fivt/img/segm_picture.jpeg'
# скачиваем изображение
response = requests.get(url, stream=True).raw

# переводим изображение в numpy-массив
input_image_np = np.asarray(bytearray(response.read()), dtype="uint8")

# переводим изображение в формат open-cv
input_image_cv2 = cv2.imdecode(input_image_np, cv2.IMREAD_COLOR)

# отображаем изображение с помощью PIL.Image
Image.fromarray(input_image_cv2[:, :, ::-1])

Пример работы с локальным изображением.

# # Считываем изображение
# input_image_cv2 = cv2.imread('путь до изображения')

# # Отображаем изображение с помощью PIL.Image
# Image.fromarray(input_image_cv2[:, :, ::-1])

Соберем конфигурацию модели, т.е. определим параметры для инициализации модели. Среди параметров укажем, какой класс моделей мы будем использовать, откуда следует загрузить параметры, а также настроим некоторый порог для предсказания. Затем инициализируем модель.

# Собираем конфигурацию
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5

# Инициализируем модель
predictor = DefaultPredictor(cfg)

Посмотрим, как выглядит модель. Она состоит из трех основных блоков: backbone, proposal_generator, roi_heads. Для чего они нужны будет рассказано на 3 курсе. Каждый из этих блоков в свою очередь состоит еще из нескольких блоков, которые в итоге построены из модулей PyTorch. Мы даже можем найти уже известные нам модули в архитектуре модели, например, Sequential в backbone.bottom_up.res2 или Linear и ReLU в roi_heads.box_head.

predictor.model

GeneralizedRCNN(
  (backbone): FPN(
    (fpn_lateral2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral3): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral4): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral5): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (top_block): LastLevelMaxPool()
    (bottom_up): ResNet(
      (stem): BasicStem(
        (conv1): Conv2d(
          3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
      )
      (res2): Sequential(
        (0): BottleneckBlock(
          (shortcut): Conv2d(
            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv1): Conv2d(
            64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv2): Conv2d(
            64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv3): Conv2d(
            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
        )
        (1): BottleneckBlock(
          (conv1): Conv2d(
            256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv2): Conv2d(
            64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv3): Conv2d(
            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
        )
        (2): BottleneckBlock(
          (conv1): Conv2d(
            256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv2): Conv2d(
            64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
          )
          (conv3): Conv2d(
            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
        )
      )
      (res3): Sequential(
        (0): BottleneckBlock(
          (shortcut): Conv2d(
            256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv1): Conv2d(
            256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv2): Conv2d(
            128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv3): Conv2d(
            128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
        )
        (1): BottleneckBlock(
          (conv1): Conv2d(
            512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv2): Conv2d(
            128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv3): Conv2d(
            128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
        )
        (2): BottleneckBlock(
          (conv1): Conv2d(
            512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv2): Conv2d(
            128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv3): Conv2d(
            128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
        )
        (3): BottleneckBlock(
          (conv1): Conv2d(
            512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv2): Conv2d(
            128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
          )
          (conv3): Conv2d(
            128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
        )
      )
      (res4): Sequential(
        (0): BottleneckBlock(
          (shortcut): Conv2d(
            512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
          (conv1): Conv2d(
            512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
        (1): BottleneckBlock(
          (conv1): Conv2d(
            1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
        (2): BottleneckBlock(
          (conv1): Conv2d(
            1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
        (3): BottleneckBlock(
          (conv1): Conv2d(
            1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
        (4): BottleneckBlock(
          (conv1): Conv2d(
            1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
        (5): BottleneckBlock(
          (conv1): Conv2d(
            1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv2): Conv2d(
            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
          )
          (conv3): Conv2d(
            256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
          )
        )
      )
      (res5): Sequential(
        (0): BottleneckBlock(
          (shortcut): Conv2d(
            1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
          )
          (conv1): Conv2d(
            1024, 512, kernel_size=(1, 1), stride=(2, 2), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv2): Conv2d(
            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv3): Conv2d(
            512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
          )
        )
        (1): BottleneckBlock(
          (conv1): Conv2d(
            2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv2): Conv2d(
            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv3): Conv2d(
            512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
          )
        )
        (2): BottleneckBlock(
          (conv1): Conv2d(
            2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv2): Conv2d(
            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
          )
          (conv3): Conv2d(
            512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False
            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
          )
        )
      )
    )
  )
  (proposal_generator): RPN(
    (rpn_head): StandardRPNHead(
      (conv): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (objectness_logits): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))
      (anchor_deltas): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))
    )
    (anchor_generator): DefaultAnchorGenerator(
      (cell_anchors): BufferList()
    )
  )
  (roi_heads): StandardROIHeads(
    (box_pooler): ROIPooler(
      (level_poolers): ModuleList(
        (0): ROIAlign(output_size=(7, 7), spatial_scale=0.25, sampling_ratio=0, aligned=True)
        (1): ROIAlign(output_size=(7, 7), spatial_scale=0.125, sampling_ratio=0, aligned=True)
        (2): ROIAlign(output_size=(7, 7), spatial_scale=0.0625, sampling_ratio=0, aligned=True)
        (3): ROIAlign(output_size=(7, 7), spatial_scale=0.03125, sampling_ratio=0, aligned=True)
      )
    )
    (box_head): FastRCNNConvFCHead(
      (flatten): Flatten(start_dim=1, end_dim=-1)
      (fc1): Linear(in_features=12544, out_features=1024, bias=True)
      (fc_relu1): ReLU()
      (fc2): Linear(in_features=1024, out_features=1024, bias=True)
      (fc_relu2): ReLU()
    )
    (box_predictor): FastRCNNOutputLayers(
      (cls_score): Linear(in_features=1024, out_features=81, bias=True)
      (bbox_pred): Linear(in_features=1024, out_features=320, bias=True)
    )
    (mask_pooler): ROIPooler(
      (level_poolers): ModuleList(
        (0): ROIAlign(output_size=(14, 14), spatial_scale=0.25, sampling_ratio=0, aligned=True)
        (1): ROIAlign(output_size=(14, 14), spatial_scale=0.125, sampling_ratio=0, aligned=True)
        (2): ROIAlign(output_size=(14, 14), spatial_scale=0.0625, sampling_ratio=0, aligned=True)
        (3): ROIAlign(output_size=(14, 14), spatial_scale=0.03125, sampling_ratio=0, aligned=True)
      )
    )
    (mask_head): MaskRCNNConvUpsampleHead(
      (mask_fcn1): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (mask_fcn2): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (mask_fcn3): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (mask_fcn4): Conv2d(
        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (deconv): ConvTranspose2d(256, 256, kernel_size=(2, 2), stride=(2, 2))
      (deconv_relu): ReLU()
      (predictor): Conv2d(256, 80, kernel_size=(1, 1), stride=(1, 1))
    )
  )
)

Сделаем предсказание.

outputs = predictor(input_image_cv2)

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

visualizer = Visualizer(
    input_image_cv2[:, :, ::-1],
    MetadataCatalog.get(cfg.DATASETS.TRAIN[0]),
    scale=1.2
)
visualizer = visualizer.draw_instance_predictions(outputs["instances"].to("cpu"))
Image.fromarray(visualizer.get_image())

Теперь решим слегка иную задачу. Она отличается от предыдущей тем, что кроме уже определенных категорий объектов, требуется также определить фоновые области: небо, здания, тротуар и т.д. В области компьютерного зрения эта задача имеет свое название — паноптическая сегментация / panoptic segmentation.

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

# Собираем конфигурацию
cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-PanopticSegmentation/panoptic_fpn_R_101_3x.yaml"))
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-PanopticSegmentation/panoptic_fpn_R_101_3x.yaml")
predictor = DefaultPredictor(cfg)

Сделаем предсказание.

outputs = predictor(input_image_cv2)

По сравнению с результатом применения предыдущей модели, мы теперь видим, что модель определила тротуар, здания, небо и деревья.

visualizer = Visualizer(
    input_image_cv2[:, :, ::-1],
    MetadataCatalog.get(cfg.DATASETS.TRAIN[0]),
    scale=1.2
)
panoptic_seg, segments_info = outputs["panoptic_seg"]
visualizer = visualizer.draw_panoptic_seg_predictions(panoptic_seg.to("cpu"), segments_info)
Image.fromarray(visualizer.get_image())

2. Детекция точек лица

Детекция точек лица заключается в том, чтобы найти на фотографии ключевые точки, которые обозначают разные части рта, носа, глаз и т.д. Это нужно, например, для того, чтобы переносить мимику актеров на персонажей фильма или игры. Для решения этой задачи мы будем использовать библиотеку face-alignment.

# !pip install -q face_alignment

import face_alignment
import urllib

Скачаем изображение.

# Скачиваем изображение
urllib.request.urlretrieve("https://miptstats.github.io/courses/ad_fivt/img/raigor.jpeg", "face.jpg")

# Отображаем изображение
face_image = Image.open('face.jpg')
face_image

Применим модель.

# Инициализируем модель
fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D, flip_input=False)

# Делаем предсказания
preds = fa.get_landmarks(np.array(face_image))

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

plt.figure(figsize=(25, 25))
plt.axis("off")
plt.imshow(face_image)
for face_keypoints in preds:
    plt.scatter(face_keypoints[:, 0], face_keypoints[:, 1], color="red")

3. Генерация текста

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

Задача генерации текста особенно актуальна для диалоговых систем, где модель должна поддерживать разговор с человеком. Будем использовать самую популярную библиотеку для применения нейронных моделей к текстам — transformers.

# !pip install -q accelerate diffusers transformers

from transformers import AutoTokenizer, AutoModelWithLMHead
from transformers import logging

Будем работать с моделью от Тинькофф, которая способна генерировать текст на русском языке.

tokenizer = AutoTokenizer.from_pretrained("tinkoff-ai/ruDialoGPT-medium")
model = AutoModelWithLMHead.from_pretrained("tinkoff-ai/ruDialoGPT-medium")
model.to("cuda");

/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:88: UserWarning: 
The secret `HF_TOKEN` does not exist in your Colab secrets.
To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.
You will be able to reuse this secret in all of your notebooks.
Please note that authentication is recommended but still optional to access public models or datasets.
  warnings.warn(

tokenizer_config.json:   0%|          | 0.00/565 [00:00<?, ?B/s]

vocab.json:   0%|          | 0.00/1.71M [00:00<?, ?B/s]

merges.txt:   0%|          | 0.00/1.27M [00:00<?, ?B/s]

added_tokens.json:   0%|          | 0.00/107 [00:00<?, ?B/s]

special_tokens_map.json:   0%|          | 0.00/379 [00:00<?, ?B/s]

Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.
Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.
/usr/local/lib/python3.10/dist-packages/transformers/models/auto/modeling_auto.py:1595: FutureWarning: The class `AutoModelWithLMHead` is deprecated and will be removed in a future version. Please use `AutoModelForCausalLM` for causal language models, `AutoModelForMaskedLM` for masked language models and `AutoModelForSeq2SeqLM` for encoder-decoder models.
  warnings.warn(

config.json:   0%|          | 0.00/874 [00:00<?, ?B/s]

pytorch_model.bin:   0%|          | 0.00/1.52G [00:00<?, ?B/s]

/usr/local/lib/python3.10/dist-packages/torch/_utils.py:831: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()
  return self.fget.__get__(instance, owner)()

Сымитируем диалог с моделью. Для этого будем каждый раз подавать в модель историю всего диалога, а она будет генерировать ответ. При этом специальным образом укажем, что мы работаем в режиме диалога — свои реплики будем помечать от имени @@ПЕРВЫЙ@@, а реплики модели от имени @@ВТОРОЙ@@.

Заметим, что результат диалога будет зависеть как от вводимого нами текста, так и от случайности.

N_STEPS = 5

context = ""

for step in range(N_STEPS):
    # Получаем текст от пользователя
    user_text = input("===> Пользователь: ")

    # Создаем контекст для модели
    context += f"@@ПЕРВЫЙ@@ {user_text} @@ВТОРОЙ@@ "

    # Превращаем текст в тензоры
    input_tokens = tokenizer(context, return_tensors='pt').to("cuda")

    # Генерируем ответ
    generated_tokens = model.generate(
        **input_tokens,
        top_k=10,
        top_p=0.95,
        num_beams=3,
        num_return_sequences=1,
        do_sample=True,
        no_repeat_ngram_size=2,
        temperature=1.5,
        repetition_penalty=1.2,
        length_penalty=1.,
        eos_token_id=50257,
        max_new_tokens=40,
    )

    # Превращаем результат генерации в текст
    context_with_gen_text = tokenizer.decode(generated_tokens[0])

    # Отделяем сгенерированный текст от контекста
    gen_text = context_with_gen_text[context_with_gen_text.rfind("@@ВТОРОЙ@@ ") + 11:]
    gen_text = gen_text.replace("@@ПЕРВЫЙ@@", "Пользователь")

    # Выводим сгенерированный текст
    print(f"===> ruDialoGPT: {gen_text}")

    # Обновляем контекст
    context += gen_text.replace("Пользователь", "@@ПЕРВЫЙ@@") + " "

===> Пользователь: привет

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT: 👋✌🏻💜Пользователь
===> Пользователь: Как дела?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  Хорошо, спасибо 😉 а у тебя как? У меня тоже все хорошо, а ты как поживаешь? Что-то случилось? А то я волнуюсь за тебя...😊�
===> Пользователь: Все хорошо, ничего не случилось. Тебе нравится DS-поток?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  Даааааа, мне нравится, очень нравится ^_^  А что это за поток такой? Я не в курсе ツ ✌️❤�
===> Пользователь: Какого цвета красный?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  Синий, красный, желтый, зеленый, фиолетовый, розовый, оранжевый, белый, коричневый （не знаю как правильно пишется) 不好�
===> Пользователь: А что еще ты знаешь?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT: 私はわ。时本ㆍ是ﾉ你如家ㅋ�

context = ""

for step in range(N_STEPS):
    # Получаем текст от пользователя
    user_text = input("===> Пользователь: ")

    # Создаем контекст для модели
    context += f"@@ПЕРВЫЙ@@ {user_text} @@ВТОРОЙ@@ "

    # Превращаем текст в тензоры
    input_tokens = tokenizer(context, return_tensors='pt').to("cuda")

    # Генерируем ответ
    generated_tokens = model.generate(
        **input_tokens,
        top_k=10,
        top_p=0.95,
        num_beams=3,
        num_return_sequences=1,
        do_sample=True,
        no_repeat_ngram_size=2,
        temperature=1.5,
        repetition_penalty=1.2,
        length_penalty=1.,
        eos_token_id=50257,
        max_new_tokens=40,
    )

    # Превращаем результат генерации в текст
    context_with_gen_text = tokenizer.decode(generated_tokens[0])

    # Отделяем сгенерированный текст от контекста
    gen_text = context_with_gen_text[context_with_gen_text.rfind("@@ВТОРОЙ@@ ") + 11:]
    gen_text = gen_text.replace("@@ПЕРВЫЙ@@", "Пользователь")

    # Выводим сгенерированный текст
    print(f"===> ruDialoGPT: {gen_text}")

    # Обновляем контекст
    context += gen_text.replace("Пользователь", "@@ПЕРВЫЙ@@") + " "

===> Пользователь: Йо

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT: ыПользователь
===> Пользователь: приветик

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT: 💕как дела?  Как настроение? Как самочувствие? Что нового в жизни? Я так соскучилась 😭❤️✨🌿🥺�
===> Пользователь: все супер а ты как?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  хорошо, а я не знаю что и сказать.  А у тебя? Чем занимаешься? У тебя все хорошо? А то у меня все плохо. У меня нет настроения. (((( 
===> Пользователь: Что, весенняя депрессия?

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  нет, я просто скучаю по тебе. Я скучала за тобой. И за твоим настроением, и за твоими мыслями. Мне очень тебя не хватает. Ты мой самый лучший друг. �
===> Пользователь: Я рад

Setting `pad_token_id` to `eos_token_id`:50257 for open-end generation.

===> ruDialoGPT:  я тоже очень рада, что ты со мной. Мы будем всегда вместе. Счастья тебе и любви! ツ👍🏻♥ﾉ�

Меню

• Главная
• Команда
• Учебные курсы
  • Введение в анализ данных
  • DS-поток
  • Phystech@DataScience
  • Семинары по математической статистике на ФБМФ, ФМХФ
• Видеолекции
  • Python для анализа данных
  • Лекции по статистике на DS-потоке

Контакты

• mipt.stats@yandex.ru

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

Design: HTML5 UP.