Create app.py

app.py

@@ -0,0 +1,185 @@
+import requests
+import streamlit as st
+import torch
+from transformers import AutoTokenizer, LEDForConditionalGeneration
+from tensorflow.keras.models import load_model
+from transformers import TFBertForSequenceClassification, BertTokenizer
+st.set_page_config(page_title="Summarization&tweet_analysis", page_icon="📈",layout="wide")
+hide_streamlit_style = """
+            <style>
+            #MainMenu {visibility: hidden;}
+            footer {	
+	visibility: hidden;
+	
+	}
+footer:after {
+	content:'©2023 Sravathi AI Technology. All rights reserved.'; 
+	visibility: visible;
+	display: block;
+	position: relative;
+	#background-color: red;
+	padding: 5px;
+	top: 2px;
+}
+            </style>
+            """
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+import pandas as pd
+import time
+import sys
+import pickle
+#from stqdm import stqdm
+import base64
+#from tensorflow.keras.preprocessing.text import Tokenizer
+#from tensorflow.keras.preprocessing.sequence import pad_sequences
+import numpy as np
+import json
+import os
+import re
+
+#from tensorflow.keras.models import load_model
+#st.write("API examples - Dermatophagoides, Miconazole, neomycin,Iothalamate")
+
+#background_image = sys.path[1]+"/streamlit_datafile_links/audience-1853662_960_720.jpg"  # Path to your background image
+def add_bg_from_local(image_file):
+    with open(image_file, "rb") as image_file:
+        encoded_string = base64.b64encode(image_file.read())
+    st.markdown(
+    f"""
+    <style>
+    .stApp {{
+        background-image: url(data:image/{"jpg"};base64,{encoded_string.decode()});
+        background-size: cover
+    }}
+    </style>
+    """,
+    unsafe_allow_html=True
+    )
+#add_bg_from_local(background_image)  
+
+#@st.cache
+st.header('Summarization & tweet_analysis')
+def convert_df(df):
+                # IMPORTANT: Cache the conversion to prevent computation on every rerun
+                return df.to_csv(index=False).encode('utf-8')  
+col1, col2 = st.columns([4,1])
+result_csv_batch_sql = result_csv_batch_fail=result_csv_batch=result_csv4=result_csv3=result_csv1=result_csv2=0
+
+with col1:
+    models = st.selectbox(
+    'Select the option',
+    ('summarization_model1','tweet_analysis' ))
+    #try: 
+    if models == 'summarization_model1':   
+        st.markdown("")
+    else:
+         st.markdown("")
+    with st.form("form1"):
+        hide_label = """
+        <style>
+            .css-9ycgxx {
+                display: none;
+            }
+        </style>
+        """
+        text_data = st.text_input('Enter the text')
+        print(text_data)
+        st.markdown(hide_label, unsafe_allow_html=True)            
+        submitted = st.form_submit_button("Submit")
+        if submitted:
+            if models == 'summarization_model1': 
+                #torch.cuda.set_device(2)
+                tokenizer = AutoTokenizer.from_pretrained('allenai/PRIMERA-multinews')
+                model = LEDForConditionalGeneration.from_pretrained('allenai/PRIMERA-multinews')
+                #device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # get the device
+                device = "cpu"
+                model.to(device) # move the model to the device  
+                documents = text_data
+    
+                # Tokenize and encode the documents
+                inputs = tokenizer(documents, return_tensors='pt', padding=True, truncation=True,max_length=1000000)
+    
+                # Move the inputs to the device
+                inputs = inputs.to(device)
+    
+                # Generate summaries
+                outputs = model.generate(**inputs,max_length=1000000)
+    
+                # Decode the summaries
+                st.write(tokenizer.batch_decode(outputs, skip_special_tokens=True))                          
+                st.success('Prediction done successfully!', icon="✅")  
+            else:
+                    # Define the custom objects (custom layers) needed for loading the model
+                    custom_objects = {"TFBertForSequenceClassification": TFBertForSequenceClassification}
+                    
+                    # Load the best model checkpoint
+                    best_model = load_model('best_model_checkpoint_val_acc_0.8697_epoch_03.h5', custom_objects=custom_objects)
+
+                    # Assuming you already have the test set DataFrame (df_test) and tokenizer
+                    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+                    test_encodings = tokenizer(text_data, padding=True, truncation=True, return_tensors='tf')
+                    test_dataset = tf.data.Dataset.from_tensor_slices((dict(test_encodings)))
+
+                    # Make predictions on the test set using the loaded model
+                    predictions_probabilities = best_model.predict(test_dataset.batch(8))
+
+                    # Convert probabilities to one-hot encoded predictions
+                    predictions_onehot = np.eye(9)[np.argmax(predictions_probabilities, axis=1)]
+
+                    # Display or save the DataFrame with predicted labels
+                    index_arg = np.argmax(predictions_probabilities, axis=1)
+                    # Later, you can load the LabelEncoder
+                    label_encoder = joblib.load('label_encoder.joblib')
+                    result_label = label_encoder.inverse_transform(index_arg)
+
+                    # Display or save the DataFrame with predicted labels
+                    st.write("Item name: ", result_label[0])
+                    
+                    from transformers import AutoTokenizer, AutoConfig, AutoModelForSequenceClassification
+                    from scipy.special import softmax
+
+                    MODEL = f"cardiffnlp/twitter-roberta-base-sentiment-latest"
+                    tokenizer = AutoTokenizer.from_pretrained(MODEL)
+                    config = AutoConfig.from_pretrained(MODEL)
+                    # PT
+                    model = AutoModelForSequenceClassification.from_pretrained(MODEL)
+                    #model.save_pretrained(MODEL)
+                    #text = "Covid cases are increasing fast!"
+                    pred_label = []
+                    pred_scor = []
+                    def preprocess(text):
+                        new_text = []
+                        for t in text.split(" "):
+                            t = '@user' if t.startswith('@') and len(t) > 1 else t
+                            t = 'http' if t.startswith('http') else t
+                            new_text.append(t)
+                        return " ".join(new_text)
+                    def predict_pret(text):
+                        #print(text)
+                        text = preprocess(text)
+                        encoded_input = tokenizer(text, return_tensors='pt')
+                        output = model(**encoded_input)
+                        scores = output[0][0].detach().numpy()
+                        scores = softmax(scores)
+
+                        ranking = np.argsort(scores)
+                        ranking = ranking[::-1]
+                        l = config.id2label[ranking[0]]
+                        s = scores[ranking[0]]
+                        return l,s
+
+                    l,s = predict_pret(text_data)
+
+                    st.write("Sentiment is: ", l)
+
+                    st.success('Prediction done successfully!', icon="✅")                 
+        _='''
+        except Exception as e:
+            if 'NoneType' or 'not defined' in str(e):
+                st.warning('Enter the required inputs', icon="⚠️")
+            else:          
+                st.warning(str(e), icon="⚠️")
+        ''' 
+
+for i in range(30):
+    st.markdown('##')