Upload 17 files

.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
+One-layer_BiLSTM_without_dropout.keras filter=lfs diff=lfs merge=lfs -text

Decision_Tree_Model.pkl

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

LR_model.pkl

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

One-layer_BiLSTM_without_dropout.keras

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

README.md

@@ -1,3 +1,5 @@
----
-license: apache-2.0
----
+Tweet Tone Triage Technique (4T): A Secured
+Federated Deep Learning Approach
+
+You can try at:
+https://tweet-tone-triage-technique-4t.streamlit.app/

Random_Forest_Model.pkl

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

SVM_model.pkl

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

app.py

@@ -0,0 +1,547 @@
+# Import required libraries
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import io
+import streamlit as st
+from streamlit_option_menu import option_menu
+import re
+from nltk.stem import PorterStemmer
+from nltk.tokenize import word_tokenize
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.utils import pad_sequences
+import pickle
+from PIL import Image
+
+import numpy as np
+from tensorflow.keras.layers import Layer
+from tensorflow.keras.models import load_model
+from tensorflow.keras import backend as K
+
+
+# Define the custom attention layer
+class attention(Layer):
+    def __init__(self, return_sequences=True, **kwargs):
+        self.return_sequences = return_sequences
+        super(attention, self).__init__(**kwargs)
+
+    def build(self, input_shape):
+        self.W = self.add_weight(name="att_weight", shape=(input_shape[-1], 1),
+                                 initializer="normal")
+        self.b = self.add_weight(name="att_bias", shape=(input_shape[1], 1),
+                                 initializer="zeros")
+        super(attention, self).build(input_shape)
+
+    def call(self, x):
+        e = K.tanh(K.dot(x, self.W) + self.b)
+        a = K.softmax(e, axis=1)
+        output = x * a
+
+        if self.return_sequences:
+            return output
+
+        return K.sum(output, axis=1)
+
+    def get_config(self):
+        config = super(attention, self).get_config()
+        config.update({'return_sequences': self.return_sequences})
+        return config
+
+
+# Preprocessing functions
+space_pattern = '\s+'
+giant_url_regex = ('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|'
+        '[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
+mention_regex = '@[\w\-]+'
+emoji_regex = '&#[0-9]{4,6};'
+
+def preprocess(text_string):
+    parsed_text = re.sub(space_pattern, ' ', text_string)
+    parsed_text = re.sub(giant_url_regex, '', parsed_text)
+    parsed_text = re.sub(mention_regex, '', parsed_text)
+    parsed_text = re.sub('RT', '', parsed_text)
+    parsed_text = re.sub(emoji_regex, '', parsed_text)
+    parsed_text = re.sub('…', '', parsed_text)
+    return parsed_text
+
+def preprocess_clean(text_string, remove_hashtags=True, remove_special_chars=True):
+    text_string = preprocess(text_string)
+    parsed_text = text_string.lower()
+    parsed_text = re.sub('\'', '', parsed_text)
+    parsed_text = re.sub(':', '', parsed_text)
+    parsed_text = re.sub(',', '', parsed_text)
+    parsed_text = re.sub('&amp', '', parsed_text)
+
+    if remove_hashtags:
+        parsed_text = re.sub('#[\w\-]+', '', parsed_text)
+    if remove_special_chars:
+        parsed_text = re.sub('(\!|\?)+', '', parsed_text)
+    return parsed_text
+
+def strip_hashtags(text):
+    text = preprocess_clean(text, False, True)
+    hashtags = re.findall('#[\w\-]+', text)
+    for tag in hashtags:
+        cleantag = tag[1:]
+        text = re.sub(tag, cleantag, text)
+    return text
+
+# Stemming function
+stemmer = PorterStemmer()
+def stemming(text):
+    stemmed_tweets = [stemmer.stem(t) for t in text.split()]
+    return stemmed_tweets
+
+# Set the page layout to wide mode
+st.set_page_config(layout="wide")
+
+# Load the dataset
+df = pd.read_csv('labeled_data.csv')
+
+# Set Streamlit page title
+#st.title('Hate Speech and Offensive Language Analysis')
+
+# Create a vertical tab menu in the sidebar
+with st.sidebar:
+    selected = option_menu(
+        menu_title="Tweet Tone Triage Technique (4T): A Secured Federated Deep Learning Approach",  # Title of the menu
+        options=["Data Acquisition", "Data Exploration", "Data Classes Balancing", "Data Preparation", "ML Model Selection", "Try The Model", "About", "Contact"],  # Menu options
+        icons=["house","cloud", "list", "gear", "graph-up", "briefcase","info","envelope"],  # Optional icons
+        menu_icon="cast",  # Icon for the menu title
+        default_index=5,  # Default selected option
+        orientation="vertical"  # Set the orientation to vertical
+    )
+
+# Display content based on selected tab
+if selected == "Data Acquisition":
+    st.title("Hate Speech and Offensive Language Dataset")
+    st.write("""This dataset contains data related to hate speech and offensive language. 
+    Davidson introduced a dataset of tweets categorized using a crowdsourced hate speech vocabulary. 
+    These tweets were classified into three categories: hate speech, offensive language, and neither. 
+    The dataset, consisting of 24,802 labeled tweets, includes columns for the number of CrowdFlower coders, 
+    the count of hate speech and offensive language identifications, and a class label indicating 
+    the majority opinion: 0 for hate speech, 1 for offensive language, and 2 for neither.\n
+    The dataset published in:\n
+    Davidson, T., Warmsley, D., Macy, M., & Weber, I. (2017, May). Automated hate speech 
+    detection and the problem of offensive language. In Proceedings of the international 
+    AAAI conference on web and social media (Vol. 11, No. 1, pp. 512-515).
+    
+    The Dataset can be downloaded from:
+    https://www.kaggle.com/datasets/mrmorj/hate-speech-and-offensive-language-dataset  
+    https://github.com/t-davidson/hate-speech-and-offensive-language
+    """)
+    # Horizontal line separator
+    st.markdown("---")
+
+elif selected == "Data Exploration":
+    st.title("Loading and Previewing the Dataset")
+    # Create tabs
+    tab1, tab2, tab3, tab4 = st.tabs(["Dataset Information", "Dataset Description", "Dataset Overview", "Missing values"])
+
+    # Tab 1: Dataset Brief Information
+    with tab1:
+        st.subheader('Dataset Information')
+
+        # Capture the df.info() output
+        buffer = io.StringIO()
+        df.info(buf=buffer)
+        s = buffer.getvalue()
+
+        # Display the info in Streamlit
+        st.text(s)
+
+    # Tab 2: Dataset Columns Description
+    with tab2:
+        st.subheader('Dataset Columns Description')
+        st.write(df.describe(include='all'))
+
+    # Tab 3: Dataset Overview (Before Preprocessing)
+    with tab3:
+        st.subheader('Dataset Overview (Before Preprocessing)')
+        st.write(df.head(10))
+
+    # Tab 4: Check for missing data
+    with tab4:
+        # Check for missing data
+        st.subheader("Missing values in each column:")
+        st.write(df.isnull().sum())
+   
+    # Horizontal line separator
+    st.markdown("---")
+
+elif selected == "Data Classes Balancing":
+    st.title("Understanding Class Distribution")
+    # Sample Data (replace this with your actual DataFrame)
+    # Ensure 'class' is in your DataFrame (0: Hate Speech, 1: Offensive Language, 2: Neither)
+    df_fig = df['class']
+    # Class labels
+    class_labels = ['Hate Speech', 'Offensive Language', 'Neither']
+
+    # Create tabs
+    tab1, tab2 = st.tabs(["Bar Chart", "Pie Chart"])
+
+    # Tab 1: Distribution of Classes (Bar Chart)
+    with tab1:
+        st.subheader('Distribution of Classes (Bar Chart)')
+    
+        # Count occurrences of each class
+        class_counts = df_fig.value_counts().reindex([0, 1, 2], fill_value=0)
+
+        # Create a bar chart using Plotly
+        bar_fig = px.bar(
+            x=class_labels, 
+            y=class_counts.values, 
+            labels={'x': 'Class', 'y': 'Frequency'}, 
+            title='Distribution of Classes',
+            color=class_labels,
+        )
+    
+        # Show the bar chart
+        st.plotly_chart(bar_fig)
+
+    # Tab 2: Proportion of Classes (Pie Chart)
+    with tab2:
+        st.subheader('Proportion of Classes (Pie Chart)')
+    
+        # Create a pie chart using Plotly
+        pie_fig = go.Figure(
+            data=[go.Pie(
+                labels=class_labels, 
+                values=class_counts.values, 
+                hole=0.3,  # Make it a donut chart for style
+                pull=[0, 0.1, 0],  # Pull out the second slice slightly
+                marker=dict(colors=['#FF6347', '#FFD700', '#90EE90']),
+                textinfo='label+percent', 
+                hoverinfo='label+value'
+            )]
+        )
+    
+        pie_fig.update_layout(
+            title_text="Distribution of Classes (Pie Chart)",
+            showlegend=True
+        )
+    
+        # Show the pie chart
+        st.plotly_chart(pie_fig)
+        # Horizontal line separator
+        st.markdown("---")
+
+elif selected == "Data Preparation":
+    st.title("Dataset Preprocessing")
+
+    st.write("""
+    We used slight pre-processing to normalize the tweets content by:
+    A) Delete the characters outlined here (— : , ;	! ?).
+    B) Normalize hashtags into words, thus ’refugeesnotwelcome’ becomes ’refugees not welcome’.
+       This is due to the fact that such hashtags are frequently employed when creating phrases. 
+    C) We separate such hashtags using a dictionary-based lookup.
+    D) To eliminate word inflections, use lowercase to remove capital letters and stemming to overcome the problem of several forms of words.
+    E) Encode the tweets into integers and pad each tweet to the max length of 100 words.
+
+    """)
+    # Horizontal line separator
+    st.markdown("---")
+
+    # Create tabs
+    tab1, tab2, tab3, tab4 = st.tabs(["Tweets Before Preprocessing", "Cleaned Tweets", "Stemmed Tweets", "Tokenized Tweets"])
+
+    # Tab 1: Tweets Before Preprocessing
+    with tab1:
+        st.subheader('Tweets Before Preprocessing')
+        st.write(df.tweet)
+        # Horizontal line separator
+        st.markdown("---")
+
+    # Tab 2: Tweets After Cleaning
+    with tab2:
+        st.subheader('Tweets After Cleaning')
+        st.write(pd.read_csv('cleaned_tweets.csv'))
+        # Horizontal line separator
+        st.markdown("---")
+
+    # Tab 3: Tweets After Stemming
+    with tab3:
+        st.subheader('Tweets After Stemming')
+        st.write(pd.read_csv('stemmed_tweets.csv'))
+        # Horizontal line separator
+        st.markdown("---")
+
+    # Tab 4: Tweets After Tokenization
+    with tab4:
+        st.subheader('Tweets After Tokenization')
+        st.write(pd.read_csv('Tokenized_Padded_tweets.csv'))
+        # Horizontal line separator
+        st.markdown("---")
+
+elif selected == "ML Model Selection":
+    st.title("Model Selection")
+    st.write("""
+    (Classifier training and testing): Ten-fold cross-validation was used to train 
+    and test all the six classifiers (logistic regression, decision tree, random forest, 
+    naive Bayes, k-nearest neighbors, and support vector machines). We utilized 
+    traditional machine learning methods provided by the Scikit-learn Python module 
+    for classification. The Logistic Regression class uses L2 regularization with 
+    a regularization parameter C equals 0.01. The hyper parameter used value of maximum depth 
+    in decision trees and random forest equals 2. The hyper parameter used value of k in 
+    k-nearest neighbors is 5, this means that the algorithm will consider the class or value of 
+    the 5 nearest neighbors, when making predictions. In naive Bayes there are no specific default 
+    values for this algorithm, as it does not require tuning hyper parameters. The hyper parameter 
+    used value of C in SVM is 1.0.""")
+    # Horizontal line separator
+    st.markdown("---")
+    tab1, tab2 = st.tabs(["Classification Results", "Display Results Figures"])
+    # Tab 3: Table I. Classification Results
+    with tab1:
+        st.subheader('Table I. Classification Results')
+        # Define the data for the table
+        data = {
+        'Algorithm': ['Logistic Regression', 'Decision Tree', 'Random Forest', 
+                      'Naive Bayes', 'K-Nearest Neighbor', 'SVM - SVC'],
+        'Precision': ['0.83 ± 0.04', '0.77 ± 0.06', '0.77 ± 0.06', '0.71 ± 0.07', '0.79 ± 0.05', '0.78 ± 0.05'],
+        'Recall': ['0.96 ± 0.02', '1.00 ± 0.01', '1.00 ± 0.01', '0.96 ± 0.02', '0.90 ± 0.03', '1.00 ± 0.01'],
+        'F1-Score': ['0.88 ± 0.02', '0.87 ± 0.03', '0.87 ± 0.03', '0.81 ± 0.04', '0.84 ± 0.04', '0.87 ± 0.03']
+        }
+
+        # Convert the data to a pandas DataFrame
+        df_results = pd.DataFrame(data)
+
+        # Display the table in Streamlit
+        st.table(df_results)
+        # Horizontal line separator
+        st.markdown("---")
+
+    # Tab 2: Display Results Figures
+    with tab2:
+        st.subheader('Display Results Figures')
+        # Data for the table
+        data = {
+            'Algorithm': ['Logistic Regression', 'Decision Tree', 'Random Forest', 
+                          'Naive Bayes', 'K-Nearest Neighbor', 'SVM - SVC'],
+            'Precision': [0.83, 0.77, 0.77, 0.71, 0.79, 0.78],
+            'Recall': [0.96, 1.00, 1.00, 0.96, 0.90, 1.00],
+            'F1-Score': [0.88, 0.87, 0.87, 0.81, 0.84, 0.87]
+        }
+
+        # Convert the data to a pandas DataFrame (renaming it df_fig)
+        df_fig = pd.DataFrame(data)
+
+        # Create a grouped bar chart using Plotly
+        fig = go.Figure()
+
+        # Add Precision bars
+        fig.add_trace(go.Bar(x=df_fig['Algorithm'], y=df_fig['Precision'], name='Precision'))
+
+        # Add Recall bars
+        fig.add_trace(go.Bar(x=df_fig['Algorithm'], y=df_fig['Recall'], name='Recall'))
+
+        # Add F1-Score bars
+        fig.add_trace(go.Bar(x=df_fig['Algorithm'], y=df_fig['F1-Score'], name='F1-Score'))
+
+        # Update layout for grouped bars
+        fig.update_layout(
+            title='Classification Results',
+            xaxis_title='Algorithm',
+            yaxis_title='Score',
+            barmode='group',  # Group the bars side by side
+            xaxis_tickangle=-45
+        )
+        # Display the plot in Streamlit
+        st.plotly_chart(fig)
+        st.markdown("---")
+
+    st.title("Results Clarifaction")
+    st.write("""
+    Looking at the results, it appears that the Decision Tree, Random Forest, 
+    and SVM - SVC classifiers have the highest recall scores of 1.00 ± 0.01, 
+    indicating that they are able to correctly identify all positive instances. 
+    However, it's important to note that the precision scores for these classifiers 
+    are slightly lower compared to Logistic Regression and K-Nearest Neighbor. 
+    But, based on the evaluation metrics for hate speech detection in NLP, 
+    the best classifier can be determined by considering the F1-score, 
+    which is a measure of the model's overall performance. By looking at the F1-scores, 
+    Logistic Regression has the highest F1-score of 0.88 ± 0.02, followed closely by 
+    Decision Tree, Random Forest, and SVM - SVC, all with F1-scores of 0.87 ± 0.03. 
+    Therefore, based on the F1-scores, Logistic Regression appears to be the best 
+    classifier for hate speech detection in NLP. In addition, Logistic Regression has 
+    the highest precision score of 0.83 ± 0.04. It also has a relatively high recall.""")
+    # Horizontal line separator
+    st.markdown("---")
+ 
+elif selected == "Try The Model":
+    st.title("Tweet Tone Triage Application")
+    # Input box for entering the tweet
+    user_input = st.text_area("Enter the tweet:", "!!!!! RT @mleew17: boy dats cold...tyga dwn bad for cuffin dat hoe in the 1st place!!")
+
+    # Button to trigger prediction
+    if st.button('Predict'):
+        # Preprocessing steps
+        preprocessed_tweet = preprocess(user_input)
+        clean_tweet = preprocess_clean(preprocessed_tweet)
+        stripped_tweet = strip_hashtags(clean_tweet)
+        stemmed_tweet = stemming(stripped_tweet)
+    
+        # Tokenize and pad the tweet
+        tokenizer = Tokenizer()
+        tokenizer.fit_on_texts(stemmed_tweet)
+        encoded_docs = tokenizer.texts_to_sequences(stemmed_tweet)
+        encoded_docs = [item for sublist in encoded_docs for item in sublist]
+        max_length = 100
+        padded_docs = pad_sequences([encoded_docs], maxlen=max_length, padding='post')
+
+        # Map the prediction to a human-readable label
+        label_map = {0: 'Hate Speech', 1: 'Offensive Language', 2: 'Neither'}
+            
+        # Load the pre-trained Federated Deep Learning model
+        #with open('3T.pkl', 'rb') as f:
+        SFD_model = load_model("One-layer_BiLSTM_without_dropout.keras", custom_objects={'attention': attention})
+        
+        # Load the pre-trained Logistic Regression model
+        with open('LR_model.pkl', 'rb') as f:
+            LR_model = pickle.load(f)
+
+        # Load the pre-trained Decision Tree model
+        with open('Random_Forest_Model.pkl', 'rb') as f:
+            Random_Forest_Model = pickle.load(f)
+
+        # Load the pre-trained Random Forest model
+        with open('Decision_Tree_Model.pkl', 'rb') as f:
+            Decision_Tree_Model = pickle.load(f)
+
+        # Load the pre-trained SVM - SVC model
+        with open('SVM_model.pkl', 'rb') as f:
+            SVM_model = pickle.load(f)
+
+        # Horizontal line separator
+        st.markdown("---")
+        st.write(f"preprocessed_tweet: {preprocessed_tweet}")
+        st.write(f"Cleaned_tweet: {clean_tweet}")
+        st.write(f"Stripped_tweet: {stripped_tweet}")
+        st.write(f"Stemmed_tweet: {stemmed_tweet}")
+        st.write(f"Tokenized_padded_docs: {padded_docs}")
+        # Horizontal line separator
+        st.markdown("---")
+        
+        # Predict sentiment/class
+        predictions = SFD_model.predict(padded_docs)
+        y_pred = np.argmax(predictions, axis=1)
+        
+        #y_pred = SFD_model.predict(padded_docs)      
+        # Display prediction result
+        st.write(f"By Using A Secured Federated Deep Learning Model")
+        st.write(f"Prediction: {label_map[y_pred[0]]}")
+        st.write(f"Prediction_class: {y_pred}")
+        
+        # Horizontal line separator
+        st.markdown("---")
+        
+        # Predict sentiment/class
+        y_pred = LR_model.predict(padded_docs)      
+        # Display prediction result
+        st.write(f"By Using Logistic Regression algorithm")
+        st.write(f"Prediction: {label_map[y_pred[0]]}")
+        st.write(f"Prediction_class: {y_pred}")
+        # Horizontal line separator
+        st.markdown("---")
+            
+        # Predict sentiment/class
+        y_pred = Random_Forest_Model.predict(padded_docs)      
+        # Display prediction result
+        st.write(f"By Using Decision Tree algorithm")
+        st.write(f"Prediction: {label_map[y_pred[0]]}")
+        st.write(f"Prediction_class: {y_pred}")
+        # Horizontal line separator
+        st.markdown("---")
+        # Predict sentiment/class
+        y_pred = Decision_Tree_Model.predict(padded_docs)      
+        # Display prediction result
+        st.write(f"By Using Random Forest algorithm")
+        st.write(f"Prediction: {label_map[y_pred[0]]}")
+        st.write(f"Prediction_class: {y_pred}")
+        # Horizontal line separator
+        st.markdown("---")
+        # Predict sentiment/class
+        y_pred = SVM_model.predict(padded_docs)      
+        # Display prediction result
+        st.write(f"By Using SVM-SVC algorithm")
+        st.write(f"Prediction: {label_map[y_pred[0]]}")
+        st.write(f"Prediction_class: {y_pred}")
+        # Horizontal line separator
+        st.markdown("---")
+    
+elif selected == "About":
+    st.title("About This App")
+    
+    st.write("""
+    This application is designed for the analysis of hate speech and offensive language in tweets. 
+    It provides several functionalities, including:
+    
+    - Loading and exploring the dataset
+    - Understanding class distribution of hate speech, offensive language, and neutral content
+    - Preprocessing tweets (removing URLs, mentions, emojis, and special characters)
+    - Tokenizing and padding tweet sequences for machine learning models
+    - Model selection and classification of tweets using traditional machine learning classifiers
+    - Testing a trained model for real-time predictions of tweet sentiment or class
+    
+    **Key Features:**
+    
+    - Utilizes a crowdsourced dataset from Davidson et al. (2017)
+    - Supports preprocessing steps like stemming and tokenization
+    - Provides an interactive interface for exploring dataset attributes, class distributions, and preprocessing steps
+    - Enables users to test machine learning models on custom tweets
+    
+    **References:**
+    
+    - Dataset Source: Davidson, T., Warmsley, D., Macy, M., & Weber, I. (2017). Automated hate speech detection and the problem of offensive language.
+    - Available on Kaggle: https://www.kaggle.com/datasets/mrmorj/hate-speech-and-offensive-language-dataset
+    """)
+    
+    # Horizontal line separator
+    st.markdown("---")
+
+elif selected == "Contact":
+    # Set page title and header
+    st.title("Supervisors")
+
+    # Introduction text
+    st.write("This application was designed and deployed by **Tharwat El-Sayed Ismail**, under the supervision of:")
+
+    # Load images
+    ayman_image = Image.open("Ayman Elsayed.jpg")
+    abdallah_image = Image.open("Abdullah-N-Moustafa.png")
+    tharwat_image = Image.open("Tharwat Elsayed Ismail.JPG")  # Replace with your image path
+
+    # Display Prof. Dr. Ayman EL-Sayed info and image
+    st.subheader("Prof. Dr. Ayman EL-Sayed")
+    st.image(ayman_image, caption="Prof. Dr. Ayman EL-Sayed", width=200)
+    st.write("[ayman.elsayed@el-eng.menofia.edu.eg](mailto:ayman.elsayed@el-eng.menofia.edu.eg)")
+
+    # Display Dr. Abdallah Moustafa Nabil info and image
+    st.subheader("Dr. Abdallah Moustafa Nabil")
+    st.image(abdallah_image, caption="Dr. Abdallah Moustafa Nabil", width=200)
+    st.write("[abdalla.moustafa@ejust.edu.eg](mailto:abdalla.moustafa@ejust.edu.eg)")
+
+    # Display your contact info and image
+    st.subheader("Eng. Tharwat El-Sayed Ismail")
+    st.image(tharwat_image, caption="Tharwat El-Sayed Ismail", width=200)  # Adjust image size as needed
+    st.write("[tharwat.elsayed@el-eng.menofia.edu.eg](mailto:tharwat.elsayed@el-eng.menofia.edu.eg)")
+        
+    # Horizontal line separator
+    st.markdown("---")
+    st.title("Contact Me")
+    
+    st.write("""
+    I’m Tharwat El-Sayed Ismail, (Data Scientist - AI Developer) I am a Data Scientist with expertise in statistical analysis, machine learning (ML), and data visualization, I bring a wealth of experience in Python, adept at extracting actionable insights to inform strategic decisions and effectively solve real-world problems. Additionally, I am an AI Developer proficient in Python, TensorFlow, and PyTorch, specialized in creating scalable AI solutions to drive business growth and enhance user experiences. Highly skilled in machine learning, natural language processing (NLP).
+    
+    **Contact Information:**
+    
+    - **Email:** tharwat_uss89@hotmail.com
+    - **LinkedIn:** [Tharwat El-Sayed](www.linkedin.com/in/tharwat-el-sayed-706276b1/)
+    - **Portfolio:** [View My Work](https://linktr.ee/tharwat.elsayed)
+    
+    I look forward to connecting with you!
+    """)
+    
+    # Horizontal line separator
+    st.markdown("---")
+

requirements.txt

@@ -0,0 +1,15 @@
+dash == 2.17.1
+pandas == 2.2.2
+plotly == 5.22.0
+matplotlib==3.8.0
+streamlit == 1.32.0
+streamlit-option-menu==0.3.2
+vaderSentiment
+textstat
+pyenchant
+splitter
+nltk
+numpy
+scikit-learn
+tensorflow
+seaborn