Spaces:
Sleeping
Sleeping
File size: 7,400 Bytes
188456f 11ad39a 8380741 c31032a 683cfcc 11ad39a 06247a9 8380741 2cca5cf 5099e16 11ad39a f70ad97 11ad39a d6c3fe4 11ad39a 8380741 6f95ca2 8380741 11ad39a 188456f 683cfcc af40b26 683cfcc af40b26 683cfcc 8380741 188456f c7e764c 022adff 188456f 5099e16 188456f 11ad39a 2cca5cf 3404ec5 5099e16 11ad39a 188456f 11ad39a f733ef4 bff0b27 11ad39a f733ef4 bff0b27 11ad39a 188456f 11ad39a 5099e16 c3bf9cc 8380741 c3bf9cc c7e764c 8380741 6f95ca2 19ef4fe c31032a c7e764c c31032a 19ef4fe b6e1e0b 19ef4fe 06247a9 19ef4fe |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
import streamlit as st
from joblib import load
from transformers import BertTokenizer, BertForSequenceClassification
import torch
from tensorflow.keras.models import load_model
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import time
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import GPT2Tokenizer, GPT2LMHeadModel
import textwrap
tok = GPT2Tokenizer.from_pretrained('sberbank-ai/rugpt3small_based_on_gpt2')
model_checkpoint = 'cointegrated/rubert-tiny-toxicity'
toxicity_tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
toxicity_model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint)
clf = load('my_model_filename.pkl')
vectorizer = load('tfidf_vectorizer.pkl')
scaler = load('scaler.joblib')
tukinazor = load('tokenizer.pkl')
rnn_model = load_model('path_to_my_model.h5')
bert_model = BertForSequenceClassification.from_pretrained('my_bert_model')
tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-cased')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
bert_model = bert_model.to(device)
model_finetuned = GPT2LMHeadModel.from_pretrained('GPT_2')
labels = ["не токсичный", "оскорбляющий", "непристойный", "угрожающий", "опасный"]
def text2toxicity(text, aggregate=True):
""" Calculate toxicity of a text (if aggregate=True) or a vector of toxicity aspects (if aggregate=False)"""
with torch.no_grad():
inputs = toxicity_tokenizer(text, return_tensors='pt', truncation=True, padding=True).to(toxicity_model.device)
proba = torch.sigmoid(toxicity_model(**inputs).logits).cpu().numpy()
if isinstance(text, str):
proba = proba[0]
if aggregate:
return 1 - proba.T[0] * (1 - proba.T[-1])
else:
result = {}
for label, prob in zip(labels, proba):
result[label] = prob
return result
def predict_text(text):
sequences = tukinazor.texts_to_sequences([text])
padded_sequences = tf.keras.preprocessing.sequence.pad_sequences(sequences, maxlen=200, padding='post', truncating='post')
predictions = rnn_model.predict(padded_sequences)
predicted_class = tf.argmax(predictions, axis=-1).numpy()[0]
return predicted_class
def generate_text(model, prompt, max_length=150, temperature=1.0, num_beams=10, top_k=600, top_p=0.75, no_repeat_ngram_size=1, num_return_sequences=1):
input_ids = tok.encode(prompt, return_tensors='pt').to(device)
with torch.inference_mode():
output = model.generate(
input_ids=input_ids,
max_length=max_length,
num_beams=num_beams,
do_sample=True,
temperature=temperature,
top_k=top_k,
top_p=top_p,
no_repeat_ngram_size=no_repeat_ngram_size,
num_return_sequences=num_return_sequences
)
texts = [textwrap.fill(tok.decode(out), 60) for out in output]
return "\n------------------\n".join(texts)
def page_reviews_classification():
st.title("Модель классификации отзывов")
st.image("ramsey.jpg", use_column_width=True)
user_input = st.text_area("Введите текст отзыва:")
if st.button("Классифицировать"):
start_time = time.time()
user_input_vec = vectorizer.transform([user_input])
sentence_vector_scaled = scaler.transform(user_input_vec)
prediction = clf.predict(
sentence_vector_scaled)
elapsed_time = time.time() - start_time
st.write(f"Прогнозируемый класс: {prediction[0]}")
st.write(f"Время вычисления: {elapsed_time:.2f} сек.")
user_input_rnn = st.text_area("Введите текст отзыва для RNN модели:")
if st.button("Классифицировать с RNN"):
start_time = time.time()
prediction_rnn = predict_text(user_input_rnn)
elapsed_time = time.time() - start_time
st.write(f"Прогнозируемый класс с RNN: {prediction_rnn}")
st.write(f"Время вычисления: {elapsed_time:.2f} сек.")
user_input_bert = st.text_area("Введите текст отзыва для BERT:")
if st.button("Классифицировать (BERT)"):
start_time = time.time()
encoding = tokenizer.encode_plus(
user_input_bert,
add_special_tokens=True,
max_length=200,
return_token_type_ids=False,
padding='max_length',
truncation=True,
return_attention_mask=True,
return_tensors='pt'
)
input_ids = encoding['input_ids'].to(device)
attention_mask = encoding['attention_mask'].to(device)
with torch.no_grad():
outputs = bert_model(input_ids=input_ids, attention_mask=attention_mask)
predictions = torch.argmax(outputs.logits, dim=1)
elapsed_time = time.time() - start_time
st.write(f"Прогнозируемый класс (BERT): {predictions.item() + 1}")
st.write(f"Время вычисления: {elapsed_time:.2f} сек.")
def page_toxicity_analysis():
st.title("Оценка текста на токсичность")
st.image("scale_1200.webp", use_column_width=True)
user_input_toxicity = st.text_area("Введите текст для оценки токсичности:")
if st.button("Оценить токсичность"):
start_time = time.time()
probs = text2toxicity(user_input_toxicity, aggregate=False)
elapsed_time = time.time() - start_time
for label, prob in probs.items():
st.write(f"Вероятность того что комментарий {label}: {prob:.4f}")
def page_gpt_generation():
st.title("Генерация текста с помощью GPT-модели")
st.image("noize-mc-2_50163340_orig_.jpg", use_column_width=True)
user_prompt = st.text_area("Введите ваш текст:")
sequence_length = st.slider("Длина последовательности:", min_value=10, max_value=1000, value=150, step=10)
num_generations = st.slider("Число генераций:", min_value=1, max_value=10, value=1)
temperature = st.slider("Температура:", min_value=0.1, max_value=3.0, value=1.0, step=0.1)
if st.button("Генерировать"):
for _ in range(num_generations):
generated_text = generate_text(model_finetuned, user_prompt, sequence_length, temperature)
st.text(generated_text)
def main():
page_selection = st.sidebar.selectbox("Выберите страницу:", ["Классификация отзывов", "Анализ токсичности","Генерация текста Noize MC"])
if page_selection == "Классификация отзывов":
page_reviews_classification()
elif page_selection == "Анализ токсичности":
page_toxicity_analysis()
elif page_selection == "Генерация текста Noize MC":
page_gpt_generation()
if __name__ == "__main__":
main() |