First version

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Kirill Gelvan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,127 @@
+import random
+import torch
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from util_funcs import getLengthParam, calcAnswerLengthByProbability, cropContext
+
+def chat_function(Message):   # model, tokenizer
+
+    input_user = Message
+
+    history = gr.get_state() or []
+
+    chat_history_ids = torch.zeros((1, 0), dtype=torch.int) if history == [] else torch.tensor(history[-1][2], dtype=torch.long)
+
+    # encode the new user input, add parameters and return a tensor in Pytorch
+    lengthId = getLengthParam(input_user, tokenizer)
+    new_user_input_ids = tokenizer.encode(f"|0|{lengthId}|" \
+                                          + input_user + tokenizer.eos_token, return_tensors="pt")
+    # append the new user input tokens to the chat history
+    chat_history_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1)
+
+    # Длину ожидаемой фразы мы рассчитаем на основании последнего инпута
+    # Например, я не люблю когда на мой длинный ответ отвечают короткой фразой
+    # Но пойдем через вероятности: 
+    # при длинном инпуте 60% что будет длинный ответ (3), 30% что средний (2), 10% что короткий (1)
+    # при среднем инпуте 50% что ответ будет средний (2), и по 25% на оба остальных случая
+    # при коротком инпуте 50% что ответ будет короткий (1), 30% что средний (2) и 20% что длинный (3)
+    # см. функцию calcAnswerLengthByProbability()
+
+    next_len = calcAnswerLengthByProbability(lengthId)
+
+    # encode the new user input, add parameters and return a tensor in Pytorch
+    new_user_input_ids = tokenizer.encode(f"|1|{next_len}|", return_tensors="pt")
+
+    # append the new user input tokens to the chat history
+    chat_history_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1)
+
+    chat_history_ids = cropContext(chat_history_ids, 10)
+
+    print(tokenizer.decode(chat_history_ids[-1]))# uncomment for debug
+    
+    # save previous len
+    input_len = chat_history_ids.shape[-1]
+    # generated a response; PS you can read about the parameters at hf.co/blog/how-to-generate
+
+    temperature = 0.6
+
+    # Обрезаем контекст до нужной длины с конца
+
+    # Создадим копию изначальных данных на случай если придется перегенерировать ответ
+    chat_history_ids_initial = chat_history_ids
+
+    while True:
+      chat_history_ids = model.generate(
+        chat_history_ids,
+        num_return_sequences=1,
+        min_length = 2,
+        max_length=512,
+        no_repeat_ngram_size=3,
+        do_sample=True,
+        top_k=50,
+        top_p=0.9,
+        temperature = temperature,
+        mask_token_id=tokenizer.mask_token_id,
+        eos_token_id=tokenizer.eos_token_id,
+        unk_token_id=tokenizer.unk_token_id,
+        pad_token_id=tokenizer.pad_token_id,
+        device='cpu'
+      )
+
+      answer = tokenizer.decode(chat_history_ids[:, input_len:][0], skip_special_tokens=True)
+
+      if (len(answer) > 0 and answer[-1] != ',' and answer[-1] != ':'):
+        break
+      else:
+        if (temperature <= 0.1):
+          temperature -= 0.1
+
+        # Случай когда надо перегенерировать ответ наступил, берем изначальный тензор
+        chat_history_ids = chat_history_ids_initial
+
+    history.append((input_user, answer, chat_history_ids.tolist()))        
+    gr.set_state(history)
+    html = "<div class='chatbot'>"
+    for user_msg, resp_msg, _ in history:
+        if user_msg != '-':
+            html += f"<div class='user_msg'>{user_msg}</div>"
+        if resp_msg != '-':
+            html += f"<div class='resp_msg'>{resp_msg}</div>"
+    html += "</div>"
+    return html
+
+# Download checkpoint:
+
+checkpoint = "avorozhko/ruDialoGpt3-medium-finetuned-context"
+tokenizer =  AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForCausalLM.from_pretrained(checkpoint)
+model = model.eval()
+
+# Gradio
+title = "Чат-бот для поднятия настроения"
+description = """
+Данный бот постарается поднять вам настроение, так как он знает 26700 анекдотов.
+Но чувство юмора у него весьма специфичное.
+Бот не знает матерных слов и откровенных пошлостей, но кто такой Вовочка и Поручик Ржевский знает )
+              """
+article = "<p style='text-align: center'><a href='https://huggingface.co/avorozhko/ruDialoGpt3-medium-finetuned-context'>Бот на основе дообученной GPT-3</a></p>"
+
+iface = gr.Interface(fn=chat_function,
+                     inputs=gr.inputs.Textbox(lines=3, placeholder="Что вы хотите сказать боту..."),
+                     outputs="html",
+                     title=title, description=description, article=article,
+                     theme='dark-grass',
+                     css= """
+                            .chatbox {display:flex;flex-direction:column}
+                            .user_msg, .resp_msg {padding:4px;margin-bottom:4px;border-radius:4px;width:80%}
+                            .user_msg {background-color:#1e4282;color:white;align-self:start}
+                            .resp_msg {background-color:#552a2a;align-self:self-end}
+                            .panels.unaligned {flex-direction: column !important;align-items: initial!important;}
+                            .panels.unaligned :last-child {order: -1 !important;}
+                          """,
+                     allow_screenshot=False,
+                     allow_flagging=False
+                    )
+
+if __name__ == "__main__":
+  iface.launch(debug=False)

requirements.txt

@@ -0,0 +1,3 @@
+transformers
+torch
+random

util_funcs.py

@@ -0,0 +1,51 @@
+def getLengthParam(text: str, tokenizer) -> str:
+    tokens_count = len(tokenizer.encode(text))
+    if tokens_count <= 15:
+        len_param = '1'
+    elif tokens_count <= 50:
+        len_param = '2'
+    elif tokens_count <= 256:
+        len_param = '3'
+    else:
+        len_param = '-'
+    return len_param
+
+# Эта функция вычисляет длину ожидаемого ответа на основе инпута
+def calcAnswerLengthByProbability(lengthId):
+
+  # Вспомогательная функция, для работы с вероятностями
+  # На вход подаем список веротностей для длинного ответа (3), среднего(2), короткого 1 
+  def getLenght(probList):
+    rndNum = random.randrange(start=0, stop=100, step=1)
+    if 0 <= rndNum <= probList[0]:
+      return 3
+    elif probList[0] < rndNum <= probList[1]:
+      return 2
+    else:
+      return 1
+
+  return {
+            lengthId == '3' or lengthId == '-': getLenght([60, 90]), # до 60 - 3, от 60 до 90 2, остальное - 1
+            lengthId == '2': getLenght([25, 75]), # до 25 - 3, от 25 до 75 - 2, остальное - 2
+            lengthId == '1': getLenght([20, 50]), # до 20 - 3, от 20 до 50 - 2, остальное - 1
+    }[True]
+
+# Функция для обрезки контекста
+# tensor - входной тензор
+# size - сколько ПОСЛЕДНИХ ответов нужно оставить
+def cropContext(tensor, size):
+  # переводим в размерность, удобную для работы
+  tensor = tensor[-1]
+  # Список, содержащий начала предложений
+  beginList = []
+
+  for i, item in enumerate(tensor):
+    if (i < len(tensor) - 5 and item == 96 and tensor[i + 2] == 96 and tensor[i + 4] == 96):
+      beginList.append(i)
+
+  if (len(beginList) < size):
+    return torch.unsqueeze(tensor, 0)
+
+  neededIndex = beginList[-size]
+  # Возвращаем в нужном нам формате (добавляем одну размерность)
+  return torch.unsqueeze(tensor[neededIndex:], 0)