add data files

Dockerfile

@@ -0,0 +1,14 @@
+# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "main:app"]

bi_encoder.py

@@ -0,0 +1,54 @@
+import pandas as pd
+import pickle
+import torch
+from transformers import AutoTokenizer, AutoModel
+from sklearn.metrics.pairwise import cosine_similarity
+
+tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
+bert_model = AutoModel.from_pretrained("distilbert-base-uncased")
+
+
+def mean_pool(token_embeds: torch.tensor, attention_mask: torch.tensor) -> torch.tensor:
+    in_mask = attention_mask.unsqueeze(-1).expand(token_embeds.size()).float()
+    pool = torch.sum(token_embeds * in_mask, 1) / torch.clamp(in_mask.sum(1), min=1e-9)
+    return pool
+
+
+def encode(input_texts: list[str], tokenizer: AutoTokenizer, model: AutoModel, device: str = "cpu"
+) -> torch.tensor:
+
+    model.eval()
+    tokenized_texts = tokenizer(input_texts, max_length=512,
+                                padding='max_length', truncation=True, return_tensors="pt")
+    token_embeds = model(tokenized_texts["input_ids"].to(device),
+                         tokenized_texts["attention_mask"].to(device)).last_hidden_state
+    pooled_embeds = mean_pool(token_embeds, tokenized_texts["attention_mask"].to(device))
+    return pooled_embeds
+
+
+with open('data/sentences.pkl', 'rb') as f:
+    sentences = pickle.load(f)
+
+with open('data/corpus.pkl', 'rb') as f:
+    corpus = pickle.load(f)
+
+df = pd.DataFrame.from_dict(sentences)
+df['corpus'] = corpus
+
+
+def get_question(context: str, question: str):
+    cont_quest = f"{context} [Cont_token] {question}"
+    pooled_embeds = encode(cont_quest, tokenizer, bert_model, "cpu")
+    pooled_embeds = pooled_embeds.cpu().detach().numpy()
+    return pooled_embeds
+
+
+def cosine_sim(question, embed):
+    return cosine_similarity(question, embed)[0][0]
+
+
+def get_corpus(context: str, question: str):
+    question_embed = get_question(context, question)
+    df['cosine_similarity'] = df.apply(lambda x: cosine_sim(question_embed, x['embeds']), axis=1)
+    corp = df.sort_values(by=['cosine_similarity'], ascending=False).head(10)['corpus'].tolist()
+    return corp

corssencode_inference.py

@@ -0,0 +1,57 @@
+from typing import List, Tuple, Any
+
+import numpy as np
+from transformers import AutoTokenizer
+from bi_encoder import get_corpus, get_question
+
+import torch
+
+from model import CrossEncoderBert
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+model = CrossEncoderBert()
+model.model.resize_token_embeddings(len(model.tokenizer))
+model.load_state_dict(torch.load('model/torch_model', map_location=torch.device(device)))
+model.tokenizer = AutoTokenizer.from_pretrained('model/tokenizer')
+model.to(device)
+
+
+def get_range_answers(
+                      context: str,
+                      question: str,
+                      num_answers: int = 5) -> list[str]:
+
+    corpus = get_corpus(context, question)
+    context_question = f'{context} [Cont_token] {question}'
+    context_questions = [context_question] * len(corpus)
+    tokenized_texts = model.tokenizer(
+        context_questions,
+        corpus,
+        max_length=512,
+        padding=True,
+        truncation=True,
+        return_tensors='pt'
+    ).to(device)
+
+    with torch.no_grad():
+        ce_scores = model(tokenized_texts['input_ids'],
+                          tokenized_texts['attention_mask']).squeeze(-1)
+        ce_scores = torch.sigmoid(ce_scores)
+
+    scores = ce_scores.cpu().numpy()
+    scores_ix = np.argsort(scores)[::-1]
+    best_answers = []
+    for idx in scores_ix[:num_answers]:
+        best_answers.append((scores[idx], corpus[idx]))
+
+    best_answers = [str(x[1]) for x in best_answers]
+    return best_answers
+
+
+def get_best_answer(
+        context: str,
+        question: str
+) -> str:
+    return get_range_answers(context, question, 1)[0][1]

data/corpus.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6dc57f8da9666e2889503c73a6ab21d85f38a9fcd1650a289468ca2a06841c8
+size 1070772

data/dataset.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef2ff6bc63bafa936eb743eb3bbfdd9ebd3192e8ba9e1bbe212cf53093a478a7
+size 3360049

data/sentences.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fb9226181cc8dacaac4ea03baf363be24a5df81d1f8ce70fa85b7b71016c4ef
+size 37335519

main.py

@@ -0,0 +1,35 @@
+from flask import Flask, render_template, request, jsonify
+from corssencode_inference import get_range_answers, get_best_answer
+
+app = Flask(__name__)
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        if request.form.get('get_answer') == 'One answer':
+            one_answer = get_best_answer(request.form.get('context'), request.form.get('question'))
+
+            return jsonify(
+                {
+                    "response_code": "200",
+                    "request": f"{request.form.get('context')} [Cont_token] {request.form.get('question')}",
+                    "response": one_answer
+                }
+            )
+        elif request.form.get('get_answer_corpus') == 'Five answer':
+            many_answer = get_range_answers(request.form.get('context'), request.form.get('question'))
+
+            return jsonify(
+                {
+                    "response_code": "200",
+                    "request": f"{request.form.get('context')} [Cont_token] {request.form.get('question')}",
+                    "response": many_answer
+                }
+            )
+    elif request.method == 'GET':
+        return render_template('index.html')
+
+
+if __name__ == '__main__':
+    app.run('localhost', 5000)

model.py

@@ -0,0 +1,16 @@
+from transformers import AutoTokenizer, AutoModel
+import torch
+
+
+class CrossEncoderBert(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = AutoModel.from_pretrained('distilbert-base-uncased')
+        self.tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')
+        self.tokenizer.add_tokens(["[Cont_token]"], special_tokens=True)
+        self.linear = torch.nn.Linear(self.model.config.hidden_size, 1)
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.last_hidden_state[:, 0]
+        return self.linear(pooled_output)

templates/index.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Chat with Sheldon</title>
+</head>
+<body>
+    <h2 style="font-style:italic; text-align:center">Chat bot Sheldon</h2>
+
+    <p style="text-align:center">Home work 1</p>
+
+    <p style="text-align:center">by Petrov DE</p>
+
+    <hr />
+    <div>
+        <p style="text-align:center">Answer: {{ answer }}</p>
+    </div>
+    <form method="post" action="/" style="text-align:center">
+        <label>
+            Context:
+        </label>
+        <label>
+            <input type="text" name="context"/>
+        </label>
+        <label>
+            Question:
+        </label>
+        <label>
+            <input type="text" name="question"/>
+        </label>
+        <input type="submit" value="One answer" name="get_answer"/>
+        <input type="submit" value="Five answer" name="get_answer_corpus" />
+    </form>
+</body>
+</html>