files added

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,3 @@
+import streamlit as st
+
+st.title('A multipage application featuring various Natural Language Processing instruments and functions.')

basic_bert_weights.pt

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

bert_weights.pt

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

borgesian_weights.pt

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

lstm_embedding_matrix.npy

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

lstm_model_weights.pt

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

lstm_vocab_to_int.json

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

pages/Borgesian.py

@@ -0,0 +1,32 @@
+import streamlit as st
+import transformers
+import torch
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+
+borgesian = GPT2LMHeadModel.from_pretrained('sberbank-ai/rugpt3small_based_on_gpt2', output_attentions = False, output_hidden_states = False)
+borgesian.load_state_dict(torch.load('borgesian_weights.pt', map_location=torch.device('cpu')))
+tokenizer = GPT2Tokenizer.from_pretrained("sberbank-ai/rugpt3small_based_on_gpt2")
+borgesian.to('cpu')
+borgesian.eval()
+
+def generate_response(text, temperature, length, top_p):
+    input_ids = tokenizer.encode(text, return_tensors="pt")
+    with torch.no_grad():
+        out = borgesian.generate(input_ids, do_sample=True, num_beams=2, temperature=float(temperature), top_p=float(top_p), max_length=length)
+    generated_text = list(map(tokenizer.decode, out))[0]
+    st.write(generated_text)
+
+st.title('Borgesian')
+st.image('borges.jpg')
+st.write('Write a prompt in Russian, and the GPT-based model will follow up with a Borgesian text.')
+st.write('Define the parameters of generation:')
+temperature = st.slider('Temperature', value = 1.5, min_value = 1.0, max_value = 5.0, step = 0.1)
+length = st.slider('Length', value = 50, min_value = 20, max_value = 150, step = 1)
+top_p = st.slider('Top-p value', value = 0.9, min_value = 0.5, max_value = 1.0, step = 0.05)
+
+user_input = st.text_area("Enter your text:")
+if st.button("Send"):
+    if user_input:
+        generate_response(user_input, temperature, length, top_p)
+    else:
+        st.warning("Please enter some text.")

pages/Film reviews classifier.py

@@ -0,0 +1,164 @@
+import streamlit as st
+import time
+import os
+import logging
+import torch
+import json
+import string
+import re
+import string
+import nltk
+import numpy as np
+import torch.nn as nn
+import transformers
+from collections import Counter
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+# stop_words = set(stopwords.words('english'))
+
+def preprocess_single_string(input_string: str, seq_len: int, vocab_to_int: dict):
+    preprocessed_string = data_preprocessing(input_string)
+    result_list = []
+    for word in preprocessed_string.split():
+        try:
+            result_list.append(vocab_to_int[word])
+        except KeyError as e:
+            continue
+    result_padded = padding([result_list], seq_len)[0]
+    return torch.tensor(result_padded)
+
+
+
+def padding(reviews_int: list, seq_len: int):
+    features = np.zeros((len(reviews_int), seq_len), dtype = int)
+    for i, review in enumerate(reviews_int):
+        if len(review) <= seq_len:
+            zeros = list(np.zeros(seq_len - len(review)))
+            new = zeros + review
+        else:
+            new = review[: seq_len]
+        features[i, :] = np.array(new)
+    return features
+
+
+def data_preprocessing(text: str):
+    wn_lemmatizer = WordNetLemmatizer()
+    text = text.lower()
+    text = re.sub('<.*?>', '', text) 
+    text = ''.join([c for c in text if c not in string.punctuation])
+    text = [wn_lemmatizer.lemmatize(word) for word in text.split()] #if word not in stop_words]
+    text = ' '.join(text)
+    return text
+
+with open('lstm_vocab_to_int.json') as json_file:
+    vocab_to_int = json.load(json_file)
+
+with open('lstm_embedding_matrix.npy', 'rb') as f:
+    embedding_matrix = np.load(f)
+
+embedding_layer = torch.nn.Embedding.from_pretrained(torch.FloatTensor(embedding_matrix))
+
+class LSTMClassifier(nn.Module):
+    def __init__(self, embedding_dim: int, seq_len:int, hidden_size:int = 32, dropout:int = 0, num_layers:int = 1) -> None:
+        super().__init__()
+
+        self.embedding_dim = embedding_dim
+        self.hidden_size = hidden_size
+        self.embedding = embedding_layer
+        self.dropout = dropout
+        self.num_layers = num_layers
+        self.seq_len = seq_len
+        self.lstm = nn.LSTM(
+            input_size=self.embedding_dim,
+            hidden_size=self.hidden_size,
+            batch_first=True,
+            bidirectional=True,
+            dropout=self.dropout,
+            num_layers=self.num_layers
+        )
+        self.linear    = nn.Sequential(
+            nn.Linear(self.hidden_size * self.seq_len * 2, 128),
+            nn.Linear(128, 1)
+        )
+
+    def forward(self, x):
+        embeddings = self.embedding(x)
+        output, _ = self.lstm(embeddings)
+        output = output.contiguous().view(output.size(0), -1)
+        out = self.linear(output.squeeze(0))
+        return out
+    
+bert_model_class = transformers.DistilBertModel
+bert_tokenizer_class = transformers.DistilBertTokenizer
+bert_pretrained_weights = torch.load('basic_bert_weights.pt', map_location=torch.device('cpu'))
+bert_tokenizer = bert_tokenizer_class.from_pretrained('distilbert-base-uncased')
+bert_basic_model = bert_model_class.from_pretrained('distilbert-base-uncased')
+
+class BertReviews(nn.Module):
+    def __init__(self, model):
+        super(BertReviews, self).__init__()
+        self.bert = model
+        for param in self.bert.parameters():
+            param.requires_grad = False
+        for i in range(6):
+            self.bert.transformer.layer[i].output_layer_norm.weight.requires_grad = True
+            self.bert.transformer.layer[i].output_layer_norm.bias.requires_grad = True
+        self.fc  = nn.Linear(768, 1)
+
+    def forward(self, samples, att_masks):
+
+        embeddings = self.bert(samples, attention_mask=att_masks)
+        model_out = self.fc(embeddings[0][:, 0, :])
+
+        return embeddings, model_out
+    
+bert_model = BertReviews(bert_basic_model)
+bert_model.load_state_dict(torch.load('bert_weights.pt', map_location=torch.device('cpu')))
+bert_model.to('cpu').eval()
+
+model_lstm = LSTMClassifier(embedding_dim=64, hidden_size=64, seq_len = 150, dropout=0.5, num_layers=4)
+model_lstm.load_state_dict(torch.load('lstm_model_weights.pt', map_location=torch.device('cpu')))
+model_lstm.to('cpu').eval()
+
+
+
+def predict_sentence_lstm(text: str):
+    start_time = time.time()
+    text = preprocess_single_string(text, 150, vocab_to_int)
+    res = int(torch.sigmoid(model_lstm(text.unsqueeze(0))).cpu().detach().numpy().round())
+    end_time = time.time() 
+    execution_time = end_time - start_time
+    return res, execution_time
+
+def predict_sentence_bert(text: str):
+    start_time = time.time()
+    text = bert_tokenizer.encode(text, add_special_tokens=True, truncation=True, max_length=200)
+    text = np.array([text + [0]*(200-len(text))])
+    attention_mask = torch.Tensor(np.where(text != 0, 1, 0)).to(torch.int64)
+    text = torch.Tensor(text).to(torch.int64)
+    # output = bert_model(text, attention_mask)[1]
+    # res = output.squeeze().detach().numpy().round()
+
+    res = int(torch.sigmoid(bert_model(text, attention_mask)[1]).cpu().detach().numpy().round())
+    end_time = time.time() 
+    execution_time = end_time - start_time
+    return res, execution_time
+
+reses = {0: 'negative', 1: 'positive'}
+
+def process_text(input_text):
+    res_lstm, time_lstm = predict_sentence_lstm(input_text)
+    res_bert, time_bert = predict_sentence_bert(input_text)
+    st.write('Results:')
+    st.write(f'LSTM: {reses[res_lstm]}, execution time: {time_lstm:.2f} seconds.')
+    st.write(f'Upgraded Bert: {reses[res_bert]}, execution time: {time_bert:.2f} seconds.')
+
+st.title('Film reviews classifier')
+st.write('Write a film review in a box below, and the application, powered by two NLP models (LSTM and upgraded Bert), will tell if it is a positive or a negative review.')
+
+user_input = st.text_area("Enter your text:")
+if st.button("Send a review for processing"):
+    if user_input:
+        processed_text = process_text(user_input)
+    else:
+        st.warning("Please enter some text before processing.")

pages/Summarizer.py

@@ -0,0 +1,22 @@
+import streamlit as st
+from transformers import AutoTokenizer, BartForConditionalGeneration
+
+summarizer = BartForConditionalGeneration.from_pretrained("sshleifer/distilbart-cnn-12-6")
+tokenizer_sum = AutoTokenizer.from_pretrained("sshleifer/distilbart-cnn-12-6")
+
+def generate_summary(text, length):
+    inputs = tokenizer_sum([text], max_length=1024, return_tensors="pt")
+    summary_ids = summarizer.generate(inputs["input_ids"], num_beams=2, min_length=1, max_length=length)
+    out = tokenizer_sum.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+    st.write(out)
+
+st.title('Summarizer')
+st.write('Submit a news article in the field below, and the Bart-based model with provide a summary.')
+
+length = st.slider('Maximum length of summary', value = 50, min_value = 15, max_value = 150, step = 1)
+user_input = st.text_area("Enter your text:")
+if st.button("Send a review for processing"):
+    if user_input:
+        generate_summary(user_input, length)
+    else:
+        st.warning("Please enter some text before processing.")

requirements.txt

@@ -0,0 +1,84 @@
+altair==5.0.1
+attrs==23.1.0
+blinker==1.6.2
+cachetools==5.3.1
+certifi==2023.5.7
+charset-normalizer==3.2.0
+click==8.1.6
+cmake==3.27.0
+contourpy==1.1.0
+cycler==0.11.0
+decorator==5.1.1
+filelock==3.12.2
+fonttools==4.41.0
+fsspec==2023.6.0
+gitdb==4.0.10
+GitPython==3.1.32
+huggingface-hub==0.16.4
+idna==3.4
+importlib-metadata==6.8.0
+Jinja2==3.1.2
+joblib==1.3.1
+jsonschema==4.18.4
+jsonschema-specifications==2023.7.1
+kiwisolver==1.4.4
+lit==16.0.6
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.7.2
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.1
+nltk==3.8.1
+numpy==1.25.1
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-cupti-cu11==11.7.101
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+nvidia-cufft-cu11==10.9.0.58
+nvidia-curand-cu11==10.2.10.91
+nvidia-cusolver-cu11==11.4.0.1
+nvidia-cusparse-cu11==11.7.4.91
+nvidia-nccl-cu11==2.14.3
+nvidia-nvtx-cu11==11.7.91
+packaging==23.1
+pandas==2.0.3
+Pillow==9.5.0
+protobuf==4.23.4
+pyarrow==12.0.1
+pydeck==0.8.1b0
+Pygments==2.15.1
+Pympler==1.0.1
+pyparsing==3.0.9
+python-dateutil==2.8.2
+pytz==2023.3
+pytz-deprecation-shim==0.1.0.post0
+PyYAML==6.0.1
+referencing==0.30.0
+regex==2023.6.3
+requests==2.31.0
+rich==13.4.2
+rpds-py==0.9.2
+safetensors==0.3.1
+six==1.16.0
+smmap==5.0.0
+streamlit==1.24.1
+sympy==1.12
+tenacity==8.2.2
+tokenizers==0.13.3
+toml==0.10.2
+toolz==0.12.0
+torch==2.0.1
+torchutils==0.0.4
+tornado==6.3.2
+tqdm==4.65.0
+transformers==4.31.0
+triton==2.0.0
+typing_extensions==4.7.1
+tzdata==2023.3
+tzlocal==4.3.1
+urllib3==2.0.4
+validators==0.20.0
+watchdog==3.0.0
+zipp==3.16.2