README.md

---
license: apache-2.0
datasets:
- wikimedia/wikipedia
---

# FractalGPT/EmbedderDecoder

* **Оригинальная модель**
[[ai-forever/rugpt3small_based_on_gpt2](https://huggingface.co/ai-forever/rugpt3small_based_on_gpt2)]

* **Код генерации вдохновлен этим проектом**
[[vector2text](https://github.com/Koziev/vector2text)]

  * Заменен эмбеддер
  * Добавлена возможность задать промпт
  * Вместо нулей вектор дополняется квадратами чисел (далее можно кубами и т.д.)
  * Создан класс для генератора
  * Добавлен ранжировщик
  * Заменена модель вместо large — small
  * Убран top_p
  * Добавлен расчет среднего эмбеддинга (для ранжировщика в случае работы с массивом)
  * Добавлена работа с матрицами эмбеддингов
  * Добавлены 2 новых способа смеси эмбеддингов:
    * Эмбеддинги в первой степени из одного текста, а квадраты из другого(в эмбеддинги и их квадраты также можно включать разную по структуре информацию)
    * Передавать массив эмбеддингов и их квадратов 

* **Пример использования**


```python
import torch
import numpy as np
from torch.nn import functional as F
from transformers import GPT2Tokenizer, GPT2LMHeadModel

def top_filtering(logits, top_k):
    """
    Фильтрация top-k, в фильтрации top-p в этой задаче особо смысла нет
    код с top-p: https://github.com/ictnlp/DSTC8-AVSD/blob/master/generate.py 
    """
    assert logits.dim() == 1
    top_k = min(top_k, logits.size(-1))
    if top_k > 0:
        indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
        logits[indices_to_remove] = -float('Inf')

    return logits


class TextEmbdGenerator:
    def __init__(self, name_or_path, sbert, device = None):
        """
        Инициализация генератора текста с моделью и токенизатором.
        name_or_path: путь до модели токенизатора или ее имя для загрузки из Hugging Face.
        sbert: модель для ранжирования (такая же что и создает эбеддинги)
        """
        self.device = device

        if self.device == None:
          self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


        self.tokenizer = GPT2Tokenizer.from_pretrained(name_or_path)
        self.model = GPT2LMHeadModel.from_pretrained(name_or_path).to(self.device)
        self.sbert = sbert


    def __get_embds(self, embds, sqr_embds):
      '''Работает с матрицей эмбеддингов'''
      list_emb = []
      sq = embds if sqr_embds == None else sqr_embds

      for i, embd in enumerate(embds):
        vector = np.concatenate([embd,sq[i]**2])
        list_emb.append(list(vector))

      return torch.FloatTensor(list_emb).to(self.device)

    def __det_mean(self, embds):
      '''Получение среднего'''
      m = np.zeros((384))

      for embd in embds:
        m += embd

      m /= len(embds)
      return m

    def generate_embedding(self, embds, prompt = '', sqr_embds = None, temperature=0.26, top_k=4, max_len=100):
        """
        Генерация текста на основе начального эмбеддинга и заданного начального текста.
        """

        current_output_ids = self.tokenizer.encode(prompt) # Промпт
        embedding = self.__get_embds(embds, sqr_embds) # Матрица входа
        word_tokens = self.model.base_model.wte # Словарь токенов

        while len(current_output_ids) < max_len:
            with torch.no_grad():
                outp_ids_tensor = torch.LongTensor(current_output_ids).to(self.device) # Выходы
                token_embeddings = word_tokens(outp_ids_tensor) # эмбеддинги
                input_vectors = torch.vstack((embedding, token_embeddings)).unsqueeze(dim=0)
                output_model = self.model(inputs_embeds=input_vectors)

            logits = output_model.logits
            if isinstance(logits, tuple):
                logits = logits[0]
            logits = logits[0, -1, :]
            logits /= temperature
            logits = top_filtering(logits, top_k)
            probs = F.softmax(logits, dim=-1)

            prev = torch.multinomial(probs, 1)
            if prev.item() == self.tokenizer.eos_token_id:
                break
            current_output_ids.append(prev.item())

        output_text = self.tokenizer.decode(current_output_ids)
        return output_text.split('\n')[0]


    def cosine_similarity(self, x, y):
        """Вычисление косинусного сходства."""
        return np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y))

    def generate_with_ranker(self, embds, prompt = '', sqr_embds = None, seq=10, temperature=0.6, top_k=10, max_len=100):
        """Генерация и ранжирование текста. Поумолчанию создаются 10 текстов"""
        sequences = [self.generate_embedding(embds, prompt, sqr_embds, temperature, top_k, max_len) for _ in range(seq)]
        sequences = list(set(sequences))  # Удаление дубликатов

        # Ранжирование
        embd = self.__det_mean(embds)
        embeddings = self.sbert.encode(sequences)
        similarities = [self.cosine_similarity(embd, emb) for emb in embeddings]
        best_index = np.argmax(similarities)

        return sequences[best_index]
```

---

```bash
pip install sentence-transformers -q
```

```python
from sentence_transformers import SentenceTransformer

sbert = SentenceTransformer('FractalGPT/SbertDistil')
generator = TextEmbdGenerator('FractalGPT/EmbedderDecoder', sbert)
```

```python
embd = sbert.encode('там живут англичане')
generator.generate_with_ranker([embd])
```
```bash
>>> я бы его в Англию привез.
```


```python
embd = sbert.encode('там живут немцы')
generator.generate_with_ranker([embd], prompt = 'он всегда был в')
```
```bash
>>> он всегда был в Германии
```

```python
embd = sbert.encode('он сделает вывод на основе анализа ситуации')
generator.generate_with_ranker(embd)
```
```bash
>>> в процессе анализа ситуации необходимо выяснить:
```


```python
embd = sbert.encode('машина') - sbert.encode('колеса') + sbert.encode('крылья')
generator.generate_with_ranker([embd], 'это')
```
```bash
>>> этот самолёт
```

```python
embd = sbert.encode('полицейский - главный герой') + sbert.encode('Произошло ужасное событие в фильме')
embd /= 2
generator.generate_with_ranker([embd], 'Собеседование на')
```

```bash
>>> Собеседование на роль главного героя фильма — молодого лейтенанта полиции — происходит в доме
```


**После дообучения**



```python
embd_1 = sbert.encode('полицейский - главный герой')
embd_2 = sbert.encode('Произошло событие в фильме')

generator.generate_with_ranker([embd_1, embd_2], 'В ')
```

```bash
>>> В этом фильме главный герой - полицейский.
```

```python
embd_1 = sbert.encode('полицейский - главный герой')
embd_2 = sbert.encode('Произошло событие в фильме')

generator.generate_with_ranker([embd_1], 'Это', [embd_2])
```

```bash
>>> Это полицейский, который в полицейском участке снимается в фильме.
```

```python
embd = sbert.encode('радиоприемник')
ans = vector_answer(embd, 'Как это устроено?')
print(ans)
```

```bash
>>> Радиоволны распространяются в воздухе, создавая электромагнитное поле, которое может быть использовано для передачи информации.
```