добавление файлов

app.py

@@ -0,0 +1,196 @@
+import streamlit as st
+import pandas as pd
+import streamlit as st
+import pickle
+import time
+from typing import Tuple
+from sklearn.feature_extraction.text import TfidfVectorizer
+import transformers
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import f1_score
+import torch
+from transformers import AutoTokenizer, AutoModel
+from torch.utils.data import TensorDataset, DataLoader
+from sklearn.preprocessing import LabelEncoder
+import re
+import string
+import numpy as np
+import torch.nn as nn
+import json
+import gensim
+import torch.nn.functional as F
+
+
+st.title('10-я неделя DS. Классификация отзывов, определение токсичности и генерация текста')
+
+st.sidebar.header('Выберите страницу')
+page = st.sidebar.radio("Выберите страницу", ["Вводная информация", "Классификация отзывов", "Определение токсичности", "Генерация текста"])
+
+if page == "Вводная информация":
+        
+        st.subheader('*Задача №1*: Классификация отзывов на медицинские учреждения')
+        st.write('Задача в двух словах: необходимо дать классификацию отзыва тремя моделями, время, за которое происходит классификаци отзыва, а также таблицу сравнения моделей по F-1 macro для моделей')
+
+        st.subheader('*Задача №2*: Определение токсичности')
+        st.write('Задача в двух словах: Оценка степени токсичности пользовательского сообщения ')
+
+        st.subheader('*Задача №3*: Генерация текста')
+        st.write('Задача в двух словах: Генерация текста GPT-моделью по пользовательскому prompt')
+
+        st.subheader('☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️☀️')
+
+        st.subheader('Выполнила команда "BERT": Алексей А., Светлана, Алиса')
+
+
+if page == "Классификация отзывов":
+    # Загрузка tf-idf модели и векторайзера
+    with open('tf-idf/tf-idf.pkl', 'rb') as f:
+        model_tf = pickle.load(f)
+
+    with open('tf-idf/tf-idf_vectorizer.pkl', 'rb') as f:
+        vectorizer_tf = pickle.load(f)
+
+    # Загрузка словаря vocab_to_int и Word2Vec модели
+    with open('lstm/vocab_to_int.json', 'r') as f:
+        vocab_to_int = json.load(f)
+
+    word2vec_model = gensim.models.Word2Vec.load("lstm/word2vec.model")
+
+    stop_words = ['и', 'в', 'во', 'не', 'что', 'он', 'на', 'я', 'с', 'со', 'как', 'а', 'то', 'все', 'она', 'так', 'его', 'но', 'да', 'ты', 'к', 'у', 'же', 'вы', 'за', 'бы', 'по', 'только', 'ее', 'мне', 'было', 'вот', 'от', 'меня', 'еще', 'нет', 'о', 'из', 'ему', 'теперь', 'когда', 'даже', 'ну', 'вдруг', 'ли', 'если', 'уже', 'или', 'ни', 'быть', 'был', 'него', 'до', 'вас', 'нибудь', 'опять', 'уж', 'вам', 'ведь', 'там', 'потом', 'себя', 'ничего', 'ей', 'может', 'они', 'тут', 'где', 'есть', 'надо', 'ней', 'для', 'мы', 'тебя', 'их', 'чем', 'была', 'сам', 'чтоб', 'без', 'будто', 'чего', 'раз', 'тоже', 'себе', 'под', 'будет', 'ж', 'тогда', 'кто', 'этот', 'того', 'потому', 'этого', 'какой', 'совсем', 'ним', 'здесь', 'этом', 'один', 'почти', 'мой', 'тем', 'чтобы', 'нее', 'сейчас', 'были', 'куда', 'зачем', 'всех', 'никогда', 'можно', 'при', 'наконец', 'два', 'об', 'другой', 'хоть', 'после', 'над', 'больше', 'тот', 'через', 'эти', 'нас', 'про', 'всего', 'них', 'какая', 'много', 'разве', 'три', 'эту', 'моя', 'впрочем', 'хорошо', 'свою', 'этой', 'перед', 'иногда', 'лучше', 'чуть', 'том', 'нельзя', 'такой', 'им', 'более', 'всегда', 'конечно', 'всю', 'между']
+    
+    def data_preprocessing(text: str) -> str:
+        text = text.lower()
+        text = re.sub('<.*?>', '', text) # html tags
+        text = ''.join([c for c in text if c not in string.punctuation])# Remove punctuation
+        text = ' '.join([word for word in text.split() if word not in stop_words])
+        text = [word for word in text.split() if not word.isdigit()]
+        text = ' '.join(text)
+        return text
+
+    # Функция для предсказания класса отзыва
+    def classify_review_tf(review):
+        # Векторизация отзыва
+        review_vector = vectorizer_tf.transform([review])
+        # Предсказание
+        start_time = time.time()
+        prediction = model_tf.predict(review_vector)
+        end_time = time.time()
+        # Время предсказания
+        prediction_time = end_time - start_time
+        return prediction[0], prediction_time
+    
+    VOCAB_SIZE = len(vocab_to_int) + 1  # add 1 for the padding token
+    EMBEDDING_DIM = 32
+    HIDDEN_SIZE = 32
+    SEQ_LEN = 100
+
+    class BahdanauAttention(nn.Module):
+        def __init__(self, hidden_size: torch.Tensor = HIDDEN_SIZE) -> None:
+            super().__init__()
+
+            self.W_q = nn.Linear(hidden_size, hidden_size)
+            self.W_k = nn.Linear(hidden_size, hidden_size)
+            self.V = nn.Linear(HIDDEN_SIZE, 1)
+
+        def forward(
+            self,
+            keys: torch.Tensor,
+            query: torch.Tensor
+        ) -> Tuple[torch.Tensor, torch.Tensor]:
+            query = self.W_q(query)
+            keys = self.W_k(keys)
+
+            energy = self.V(torch.tanh(query.unsqueeze(1) + keys)).squeeze(-1)
+            weights = F.softmax(energy, -1)
+            context = torch.bmm(weights.unsqueeze(1), keys)
+            return context, weights
+    
+    embedding_matrix = np.zeros((VOCAB_SIZE, EMBEDDING_DIM))
+    embedding_layer = torch.nn.Embedding.from_pretrained(torch.FloatTensor(embedding_matrix))
+
+    class LSTMConcatAttention(nn.Module):
+        def __init__(self) -> None:
+            super().__init__()
+
+            # self.embedding = nn.Embedding(VOCAB_SIZE, EMBEDDING_DIM)
+            self.embedding = embedding_layer
+            self.lstm = nn.LSTM(EMBEDDING_DIM, HIDDEN_SIZE, batch_first=True)
+            self.attn = BahdanauAttention(HIDDEN_SIZE)
+            self.clf = nn.Sequential(
+                nn.Linear(HIDDEN_SIZE, 128),
+                nn.Dropout(),
+                nn.Tanh(),
+                nn.Linear(128, 1)
+            )
+        
+        def forward(self, x):
+            embeddings = self.embedding(x)
+            outputs, (h_n, _) = self.lstm(embeddings)
+            att_hidden, att_weights = self.attn(outputs, h_n.squeeze(0))
+            out = self.clf(att_hidden)
+            return out, att_weights
+        
+    model_lstm = LSTMConcatAttention()  # Инициализируйте с теми же параметрами, что использовались при обучении
+    model_lstm.load_state_dict(torch.load("lstm/lstm_model.pth"))
+    model_lstm.eval()
+
+        # Проверка и добавление токена <UNK>, если он отсутствует
+    if '<UNK>' not in vocab_to_int:
+        vocab_to_int['<UNK>'] = len(vocab_to_int)  # Присвоение нового уникального индекса
+
+    # Проверка и добавление токена <PAD>, если он отсутствует
+    if '<PAD>' not in vocab_to_int:
+        vocab_to_int['<PAD>'] = len(vocab_to_int)  # Присвоение нового уникального индекса
+
+    def text_to_vector(text, max_length=SEQ_LEN):
+        words = text.split()
+        vector = [vocab_to_int.get(word, vocab_to_int["<UNK>"]) for word in words][:max_length]
+        vector += [vocab_to_int["<PAD>"]] * (max_length - len(vector))  # Дополнение вектора
+        return np.array(vector, dtype=np.int64)  # Убедитесь, что тип данных int64
+
+    def classify_review_lstm(review):
+        # Векторизация отзыва
+        review_vector = text_to_vector(review)
+        # Преобразование в тензор PyTorch и добавление размерности пакета (batch)
+        review_tensor = torch.tensor(review_vector).unsqueeze(0)
+        
+        # Предсказание
+        start_time = time.time()
+        with torch.no_grad():
+            prediction, _ = model_lstm(review_tensor)
+        end_time = time.time()
+
+        # Время предсказания
+        prediction_time = end_time - start_time
+        return prediction, prediction_time
+
+    # Создание интерфейса Streamlit
+    st.title('Классификатор отзывов на клиники')
+
+    # Текстовое поле для ввода отзыва
+    user_review = st.text_input('Введите ваш отзыв на клинику')
+
+    if st.button('Классифицировать'):
+        if user_review:
+            # Классификация отзыва
+            prediction_tf, pred_time_tf = classify_review_tf(user_review)
+            st.write(f'Предсказанный класс TF-IDF: {prediction_tf}')
+            st.write(f'Время предсказания TF-IDF: {pred_time_tf:.4f} секунд')
+            prediction_lstm, pred_time_lstm = classify_review_lstm(user_review)
+            st.write(f'Предсказанный класс LSTM: {prediction_tf}')
+            st.write(f'Время предсказания LSTM: {pred_time_tf:.4f} секунд')
+        else:
+            st.write('Пожалуйста, введите отзыв')
+
+
+
+
+
+# if page == "Определение токсичности":
+    
+    
+# if page == "Генерация текста":
+
+

lstm/lstm_model.pth

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

lstm/rnn_preprocessing.py

@@ -0,0 +1,80 @@
+import re
+import string
+import numpy as np
+import torch
+
+from nltk.corpus import stopwords
+stop_words = set(stopwords.words('english'))
+
+def data_preprocessing(text: str) -> str:
+    """preprocessing string: lowercase, removing html-tags, punctuation, 
+                            stopwords, digits
+
+    Args:
+        text (str): input string for preprocessing
+
+    Returns:
+        str: preprocessed string
+    """    
+
+    text = text.lower()
+    text = re.sub('<.*?>', '', text) # html tags
+    text = ''.join([c for c in text if c not in string.punctuation])# Remove punctuation
+    text = ' '.join([word for word in text.split() if word not in stop_words])
+    text = [word for word in text.split() if not word.isdigit()]
+    text = ' '.join(text)
+    return text
+
+def get_words_by_freq(sorted_words: list, n: int = 10) -> list:
+    return list(filter(lambda x: x[1] > n, sorted_words))
+
+def padding(review_int: list, seq_len: int) -> np.array: # type: ignore
+    """Make left-sided padding for input list of tokens
+
+    Args:
+        review_int (list): input list of tokens
+        seq_len (int): max length of sequence, it len(review_int[i]) > seq_len it will be trimmed, else it will be padded by zeros
+
+    Returns:
+        np.array: padded sequences
+    """    
+    features = np.zeros((len(review_int), seq_len), dtype = int)
+    for i, review in enumerate(review_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 preprocess_single_string(
+    input_string: str, 
+    seq_len: int, 
+    vocab_to_int: dict,
+    verbose : bool = False
+    ) -> torch.tensor:
+    """Function for all preprocessing steps on a single string
+
+    Args:
+        input_string (str): input single string for preprocessing
+        seq_len (int): max length of sequence, it len(review_int[i]) > seq_len it will be trimmed, else it will be padded by zeros
+        vocab_to_int (dict, optional): word corpus {'word' : int index}. Defaults to vocab_to_int.
+
+    Returns:
+        list: preprocessed string
+    """    
+
+    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:
+            if verbose:
+                print(f'{e}: not in dictionary!')
+            pass
+    result_padded = padding([result_list], seq_len)[0]
+
+    return torch.tensor(result_padded)

lstm/word2vec.model

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

requirements.txt

@@ -0,0 +1,73 @@
+altair==5.2.0
+attrs==23.1.0
+blinker==1.7.0
+cachetools==5.3.2
+certifi==2023.11.17
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.2.0
+cycler==0.12.1
+filelock==3.13.1
+fonttools==4.46.0
+fsspec==2023.12.1
+gensim==4.3.2
+gitdb==4.0.11
+GitPython==3.1.40
+huggingface-hub==0.19.4
+idna==3.6
+importlib-metadata==6.11.0
+importlib-resources==6.1.1
+Jinja2==3.1.2
+joblib==1.3.2
+jsonschema==4.20.0
+jsonschema-specifications==2023.11.2
+kiwisolver==1.4.5
+lightning-utilities==0.10.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.8.2
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.2.1
+nltk==3.8.1
+numpy==1.26.2
+packaging==23.2
+pandas==2.1.3
+Pillow==10.1.0
+protobuf==4.25.1
+pyarrow==14.0.1
+pydeck==0.8.1b0
+Pygments==2.17.2
+pyparsing==3.1.1
+python-dateutil==2.8.2
+pytz==2023.3.post1
+PyYAML==6.0.1
+referencing==0.32.0
+regex==2023.10.3
+requests==2.31.0
+rich==13.7.0
+rpds-py==0.13.2
+safetensors==0.4.1
+scikit-learn==1.3.2
+scipy==1.11.4
+six==1.16.0
+smart-open==6.4.0
+smmap==5.0.1
+streamlit==1.29.0
+sympy==1.12
+tenacity==8.2.3
+threadpoolctl==3.2.0
+tokenizers==0.15.0
+toml==0.10.2
+toolz==0.12.0
+torch==2.1.1
+torchmetrics==1.2.1
+tornado==6.4
+tqdm==4.66.1
+transformers==4.35.2
+typing_extensions==4.8.0
+tzdata==2023.3
+tzlocal==5.2
+urllib3==2.1.0
+validators==0.22.0
+zipp==3.17.0

tf-idf/tf-idf.pkl

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

tf-idf/tf-idf_vectorizer.pkl

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