Create app.py

app.py

@@ -0,0 +1,110 @@
+import streamlit as st
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, T5ForConditionalGeneration, T5Tokenizer
+import nltk
+import torch
+from textblob import TextBlob
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+nltk.download('stopwords')
+
+# Load models and tokenizers
+tag_tokenizer = AutoTokenizer.from_pretrained("fabiochiu/t5-base-tag-generation")
+tag_model = AutoModelForSeq2SeqLM.from_pretrained("fabiochiu/t5-base-tag-generation")
+
+summary_model_name = 'utrobinmv/t5_summary_en_ru_zh_base_2048'
+summary_model = T5ForConditionalGeneration.from_pretrained(summary_model_name)
+summary_tokenizer = T5Tokenizer.from_pretrained(summary_model_name)
+
+# Function to generate tags
+def generate_tags(text):
+    with torch.no_grad():
+        inputs = tag_tokenizer(text, max_length=256, truncation=True, return_tensors="pt")
+        output = tag_model.generate(**inputs, num_beams=8, do_sample=True, min_length=10, max_length=64, num_return_sequences=1)
+        decoded_output = tag_tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+        tags = list(set(decoded_output.strip().split(", ")))
+    return tags
+
+# Function to generate summaries
+def generate_summary(text, prefix):
+    src_text = prefix + text
+    input_ids = summary_tokenizer(src_text, return_tensors="pt")
+    generated_tokens = summary_model.generate(**input_ids)
+    result = summary_tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
+    return result[0]
+
+# Function to extract keywords and generate hashtags
+def extract_keywords(content):
+    text = content.lower()
+    sentences = nltk.sent_tokenize(text)
+    keywords = []
+    for sentence in sentences:
+        words = nltk.word_tokenize(sentence)
+        tags = nltk.pos_tag(words)
+        for word, tag in tags:
+            if tag.startswith('NN'):
+                keywords.append(word)
+    return keywords
+
+def generate_hashtags(content, max_hashtags=10):
+    keywords = extract_keywords(content)
+    hashtags = []
+    for keyword in keywords:
+        hashtag = "#" + keyword
+        if len(hashtag) <= 20:
+            hashtags.append(hashtag)
+    return hashtags[:max_hashtags]
+
+# Function to extract point of view
+def extract_point_of_view(text):
+    stop_words = set(stopwords.words('english'))
+    words = word_tokenize(str(text))
+    filtered_words = [word for word in words if word.casefold() not in stop_words]
+    text = ' '.join(filtered_words)
+
+    blob = TextBlob(text)
+    polarity = blob.sentiment.polarity
+    subjectivity = blob.sentiment.subjectivity
+
+    if polarity > 0.5:
+        point_of_view = "Positive"
+    elif polarity < -0.5:
+        point_of_view = "Negative"
+    else:
+        point_of_view = "Neutral"
+
+    return point_of_view
+
+# Streamlit application
+st.title("Text Analysis Application")
+
+text = st.text_area("Enter your text here:")
+
+if st.button("Analyze"):
+    if text:
+        # Generate tags
+        tags = generate_tags(text)
+        st.subheader("Generated Tags")
+        st.write(tags)
+
+        # Generate summaries
+        summary1 = generate_summary(text, 'summary: ')
+        summary2 = generate_summary(text, 'summary brief: ')
+        st.subheader("Summary 1")
+        st.write(summary1)
+        st.subheader("Summary 2")
+        st.write(summary2)
+
+        # Generate hashtags
+        hashtags = generate_hashtags(text)
+        st.subheader("Generated Hashtags")
+        st.write(hashtags)
+
+        # Extract point of view
+        point_of_view = extract_point_of_view(text)
+        st.subheader("Point of View")
+        st.write(point_of_view)
+    else:
+        st.warning("Please enter text to analyze.")