Update app.py

app.py

@@ -1,273 +1,229 @@
 import streamlit as st
 
-# Function to redirect to different pages
-def redirect_to_page(page):
-    st.experimental_set_query_params(page=page)
-
 # Title of the app
 st.title('Natural Language Processing (NLP) Overview')
 
-# Introduction to NLP
-st.header('Introduction to Natural Language Processing (NLP)')
-st.write("""
-Natural Language Processing (NLP) is a branch of artificial intelligence (AI) that enables machines to understand, 
-interpret, and generate human language. NLP is used in a wide variety of applications, such as chatbots, search engines, 
-translation systems, and voice assistants.
-
-Some common NLP tasks include:
-- Text Classification
-- Sentiment Analysis
-- Named Entity Recognition (NER)
-- Language Translation
-- Text Summarization
-- Part-of-Speech Tagging
-
-### Importance of NLP:
-- **Automation of manual tasks**: NLP is widely used to automate tasks such as document categorization, content summarization, and sentiment analysis.
-- **Understanding and generating human language**: NLP allows machines to understand the meaning behind words, sentences, and paragraphs, making human-machine interactions more natural.
-""")
-
-# NLP Lifecycle
-st.header('NLP Lifecycle')
-st.write("""
-The NLP lifecycle consists of several stages, each contributing to transforming raw text into useful insights or predictions. Here are the stages of the NLP lifecycle:
-
-1. **Data Collection**: Collect text data from various sources such as websites, social media, surveys, etc.
-2. **Text Preprocessing**: Clean and preprocess the text data, removing unnecessary information like stopwords, punctuation, etc.
-3. **Text Representation**: Convert the preprocessed text into numerical form using methods like Bag of Words (BoW), TF-IDF, or Word Embeddings.
-4. **Model Training**: Train machine learning models on the text data to solve the NLP problem, such as classification or entity recognition.
-5. **Evaluation**: Assess the model's performance using evaluation metrics like accuracy, precision, recall, and F1-score.
-6. **Deployment**: Deploy the trained model to a real-world application, such as a chatbot or sentiment analysis tool, and continuously monitor and retrain the model as needed.
-
-These stages are crucial for building effective NLP applications that provide value to users.
-""")
-# Define the available NLP lifecycle stages
-lifecycle_stages = ['Data Collection', 'Text Preprocessing', 'Text Representation', 
-                    'Model Training', 'Evaluation', 'Deployment']
-
-# Add a selectbox for the user to choose a lifecycle stage
-selected_lifecycle_stage = st.selectbox('Choose an NLP Lifecycle Stage:', lifecycle_stages)
-
-# If lifecycle stage is selected, update query params and display new content
-if selected_lifecycle_stage:
-    redirect_to_page(selected_lifecycle_stage)
-
-# Get the page from the query params
-params = st.experimental_get_query_params()
-selected_page = params.get("page", [None])[0]
-
-# Define content for different lifecycle stages
-if selected_page == 'Data Collection':
-    st.write("""
-    ### Data Collection:
-    The first stage of the NLP lifecycle involves gathering text data from various sources such as:
-    - Social media posts
-    - Websites and blogs
-    - News articles
-    - Customer reviews
-    - Books and papers
-    
-    **Example**: Collecting customer feedback from surveys or scraping news articles to analyze sentiment.
-    
-    **Key Points**:
-    - Data must be relevant to the task you are solving (e.g., sentiment analysis, text classification).
-    - The data can be structured (e.g., databases) or unstructured (e.g., plain text from websites).
-    """)
-
-elif selected_page == 'Text Preprocessing':
-    st.write("""
-    ### Text Preprocessing:
-    Text preprocessing is essential for preparing raw text data for analysis. The steps involved include:
-    - **Tokenization**: Breaking text into smaller units like words or sentences.
-    - **Removing Stop Words**: Stop words (e.g., "the", "a", "is") are common words that don't carry much information and are often removed.
-    - **Stemming**: Reducing words to their base or root form (e.g., "running" → "run").
-    - **Lemmatization**: Similar to stemming but more accurate, it reduces words to their dictionary form (e.g., "better" → "good").
-    - **Lowercasing**: Converting all text to lowercase to avoid treating the same word in different cases (e.g., "Hello" vs "hello").
-    - **Removing Special Characters**: Eliminating punctuation marks, numbers, and other non-alphabetic characters that may not contribute to the analysis.
-    
-    **Key Points**:
-    - Preprocessing is crucial for reducing noise in the text, ensuring that the machine learning models focus on the important features.
-    """)
-
-elif selected_page == 'Text Representation':
-    st.write("""
-    ### Text Representation:
-    After preprocessing, text needs to be converted into a numerical form for machine learning algorithms. 
-    The common techniques for text representation include:
-    - **Bag of Words (BoW)**: Converts text into a matrix of word frequencies.
-    - **TF-IDF (Term Frequency - Inverse Document Frequency)**: A statistical method to evaluate the importance of a word within a document relative to a collection of documents.
-    - **Word Embeddings**: Maps words to dense vectors, preserving semantic meaning (e.g., Word2Vec, GloVe, FastText).
-    
-    **Key Points**:
-    - BoW and TF-IDF are more traditional methods, while word embeddings capture semantic relationships and are widely used in modern NLP tasks.
-    """)
-
-elif selected_page == 'Model Training':
-    st.write("""
-    ### Model Training:
-    In the model training stage, machine learning algorithms are used to train a model on the preprocessed and represented data. 
-    The choice of model depends on the task at hand. For example:
-    - For **text classification**, algorithms like Naive Bayes, SVM, or neural networks are commonly used.
-    - For **named entity recognition (NER)**, sequence models such as CRF (Conditional Random Fields) or LSTM (Long Short-Term Memory) can be used.
-    - For **sentiment analysis**, simple models like logistic regression or complex models like BERT can be employed.
-    
-    **Key Points**:
-    - The choice of model depends on the task (e.g., classification, sequence generation, summarization).
-    - The model learns patterns and relationships in the text data, which it will use to make predictions.
-    """)
-
-elif selected_page == 'Evaluation':
-    st.write("""
-    ### Evaluation:
-    Once a model is trained, it is evaluated to understand its performance. Common evaluation metrics include:
-    - **Accuracy**: The proportion of correct predictions.
-    - **Precision**: The ratio of correctly predicted positive observations to the total predicted positives.
-    - **Recall**: The ratio of correctly predicted positive observations to the total actual positives.
-    - **F1-Score**: The weighted average of precision and recall.
-    - **ROC and AUC**: Performance measurement for classification problems.
-    
-    **Key Points**:
-    - Evaluation helps determine if the model is overfitting (memorizing the training data) or underfitting (not learning the data properly).
-    - It ensures that the model will perform well on unseen data (real-world applications).
-    """)
-
-elif selected_page == 'Deployment':
-    st.write("""
-    ### Deployment:
-    The final stage is deploying the trained model for real-time use. The model can be integrated into applications like:
-    - Chatbots for customer service
-    - Sentiment analysis for social media monitoring
-    - Language translation systems
-    - Search engines for better query results
-    
-    **Key Points**:
-    - Continuous monitoring and maintenance are necessary to ensure that the model stays effective over time, especially as new data comes in.
-    - Retraining may be required periodically to account for changes in language usage or new trends in the data.
-    """)
-
-# NLP Techniques
-st.header('NLP Techniques')
-st.write("""
-Some key techniques used in NLP include:
-
-- **Tokenization**: The process of breaking down text into smaller units, such as words or sentences.
-- **Stop Word Removal**: The process of removing common words (e.g., "the", "a", "and") that do not contribute significant meaning to the text.
-- **Stemming**: Reducing words to their root form (e.g., "running" → "run").
-- **Lemmatization**: Similar to stemming but more accurate, reducing words to their dictionary form (e.g., "better" → "good").
-- **Named Entity Recognition (NER)**: Identifying entities such as people, organizations, and locations within text.
-- **Part-of-Speech Tagging**: Identifying the grammatical structure of words in a sentence, such as nouns, verbs, adjectives, etc.
-- **Word Embeddings**: A technique that maps words into continuous vector space, capturing semantic relationships between words (e.g., Word2Vec, GloVe).
-- **Text Classification**: Categorizing text into predefined labels or categories (e.g., spam detection, sentiment analysis).
-- **Sentiment Analysis**: Determining the sentiment expressed in a text, such as whether it is positive, negative, or neutral.
+# Sidebar for navigation
+sidebar = st.sidebar
 
-These techniques are the building blocks for solving various NLP tasks and are essential for developing applications that can understand human language.
-""")
+# Sidebar header
+sidebar.header('NLP Navigation')
 
+# Sidebar options for NLP Overview, Lifecycle, and Techniques
+sidebar_option = sidebar.radio('Choose a section to explore:', ['What is NLP?', 'NLP Lifecycle', 'NLP Techniques'])
 
-# Define the available NLP tasks
-tasks = ['Text Classification', 'Sentiment Analysis', 'Named Entity Recognition (NER)', 
-         'Language Translation', 'Text Summarization', 'Part-of-Speech Tagging', 
-         'Text Generation', 'Text Similarity']
+# Store the selected page in session state
+if 'selected_page' not in st.session_state:
+    st.session_state.selected_page = sidebar_option
 
-# Add a selectbox for the user to choose an NLP task
-selected_task = st.selectbox('Choose an NLP Task:', tasks)
+# Update the selected page if the user selects a different option
+if sidebar_option != st.session_state.selected_page:
+    st.session_state.selected_page = sidebar_option
 
-# If a task is selected, update query params and display new content
-if selected_task:
-    redirect_to_page(selected_task)
-
-# Get the task from the query params
-selected_task_page = params.get("page", [None])[0]
-
-# Define content for different NLP tasks
-if selected_task_page == 'Text Classification':
-    st.write("""
-    ### Text Classification:
-    Text Classification is the task of categorizing text into predefined labels. 
-    This can be used for spam detection, topic categorization, etc.
-    **Example**: Categorizing news articles into topics like 'Sports', 'Politics', etc.
-    
-    **Techniques**:
-    - Bag of Words (BoW)
-    - TF-IDF
-    - Word Embeddings
-    """)
-
-elif selected_task_page == 'Sentiment Analysis':
-    st.write("""
-    ### Sentiment Analysis:
-    Sentiment Analysis determines the sentiment of a given text, such as whether it is positive, negative, or neutral.
-    **Example**: Analyzing product reviews to determine customer satisfaction.
-    
-    **Techniques**:
-    - Lexicon-based (e.g., VADER)
-    - Machine Learning (e.g., Naive Bayes, SVM)
-    """)
-
-elif selected_task_page == 'Named Entity Recognition (NER)':
+# Content for "What is NLP?"
+if st.session_state.selected_page == 'What is NLP?':
     st.write("""
-    ### Named Entity Recognition (NER):
-    NER is the process of identifying named entities in text, such as people, organizations, dates, locations, etc.
-    **Example**: Extracting names of people and organizations from news articles.
+    ### What is NLP?
+    Natural Language Processing (NLP) is a subfield of artificial intelligence (AI) that focuses on the interaction between computers and human (natural) languages. The goal of NLP is to enable machines to understand, interpret, and generate human language in a way that is meaningful.
     
-    **Techniques**:
-    - Rule-based NER
-    - Machine Learning-based NER (e.g., CRF, LSTM)
+    NLP is essential for enabling computers to process and analyze large amounts of natural language data, such as:
+    - Text from documents
+    - Speech from conversations
+    - Images with textual descriptions
+
+    #### Key Components of NLP:
+    - **Syntax**: Refers to the arrangement of words in a sentence.
+    - **Semantics**: Focuses on the meaning of the words and sentences.
+    - **Pragmatics**: Involves the context and intent behind language.
+    - **Discourse**: Studies how previous sentences and context influence meaning.
+
+    #### Example Applications of NLP:
+    - **Machine Translation**: Automatic translation of text from one language to another (e.g., Google Translate).
+    - **Speech Recognition**: Converting spoken language into text (e.g., Siri, Alexa).
+    - **Sentiment Analysis**: Analyzing text to determine the sentiment (positive, negative, neutral) (e.g., analyzing customer reviews).
+    - **Text Summarization**: Creating a short summary of a long text (e.g., summarizing articles).
+
+    NLP is used across multiple domains like healthcare, finance, and customer service to automate and improve various tasks.
     """)
 
-elif selected_task_page == 'Language Translation':
-    st.write("""
-    ### Language Translation:
-    Language Translation involves translating text from one language to another.
-    **Example**: Translating a sentence from English to Spanish.
+# Content for NLP Lifecycle
+elif st.session_state.selected_page == "NLP Lifecycle":
+    lifecycle_option = sidebar.radio("Select NLP Lifecycle Step:", [
+        "Data Collection",
+        "Text Preprocessing",
+        "Text Representation",
+        "Model Training",
+        "Evaluation",
+        "Deployment"
+    ])
     
-    **Techniques**:
-    - Statistical Machine Translation (SMT)
-    - Neural Machine Translation (NMT)
-    """)
-
-elif selected_task_page == 'Text Summarization':
-    st.write("""
-    ### Text Summarization:
-    Text Summarization involves condensing long pieces of text into a shorter, meaningful version.
-    **Example**: Generating a summary of a long article.
+    if lifecycle_option == "Data Collection":
+        st.write("""
+        #### 1. Data Collection
+        Data collection is the first stage of the NLP lifecycle. It involves gathering relevant text data from various sources to analyze and process.
+        - **Sources**:
+            - Social media posts (e.g., tweets, Facebook status updates)
+            - News articles (e.g., for summarization or sentiment analysis)
+            - Customer reviews (e.g., on e-commerce platforms)
+            - Books and research papers (e.g., for topic modeling or classification)
+
+        **Example**: Scraping customer reviews from Amazon to analyze sentiment and feedback about a product.
+        """)
+
+    elif lifecycle_option == "Text Preprocessing":
+        st.write("""
+        #### 2. Text Preprocessing
+        Text preprocessing prepares raw text for further analysis. This stage involves cleaning and transforming the data into a structured format that machine learning models can understand.
+        - **Tokenization**: Splitting text into smaller units (e.g., words, phrases).
+        - **Stop Words Removal**: Removing common words that don’t contribute much information.
+        - **Lemmatization**: Converting words into their base or dictionary form.
+        - **Stemming**: Cutting off prefixes or suffixes from words.
+        - **Lowercasing**: Converting all characters in the text to lowercase.
+
+        **Example**: For the sentence "The quick brown fox is running fast", after preprocessing:
+        - Tokenization: ["The", "quick", "brown", "fox", "is", "running", "fast"]
+        - Stop Words Removal: ["quick", "brown", "fox", "running", "fast"]
+        - Lemmatization: ["quick", "brown", "fox", "run", "fast"]
+        """)
+
+    elif lifecycle_option == "Text Representation":
+        st.write("""
+        #### 3. Text Representation
+        After preprocessing, the text data needs to be converted into a numerical format for use in machine learning models. There are several methods for text representation:
+        - **Bag of Words (BoW)**: Converts text into a matrix of word frequencies.
+        - **TF-IDF**: Weighs words based on their frequency in a specific document relative to their frequency across the entire dataset.
+        - **Word Embeddings**: Transforms words into dense vectors that capture semantic meaning.
+
+        **Example**: Using BoW to convert the sentence "I love NLP" into a vector representation:
+        - Vocabulary: ["I", "love", "NLP"]
+        - Vector: [1, 1, 1] (word frequency representation)
+        """)
+
+    elif lifecycle_option == "Model Training":
+        st.write("""
+        #### 4. Model Training
+        In the model training stage, machine learning algorithms are trained on the preprocessed and represented text data. The choice of model depends on the task:
+        - **Text Classification**: Naive Bayes, Support Vector Machines (SVM), or neural networks.
+        - **Named Entity Recognition (NER)**: Conditional Random Fields (CRF), LSTMs, or transformers.
+        - **Sentiment Analysis**: Logistic regression, Naive Bayes, or transformer-based models like BERT.
+
+        **Example**: Training a Naive Bayes classifier to categorize news articles into topics such as "Sports", "Politics", etc.
+        """)
+
+    elif lifecycle_option == "Evaluation":
+        st.write("""
+        #### 5. Evaluation
+        After training the model, it's important to evaluate its performance. Common evaluation metrics include:
+        - **Accuracy**: The percentage of correctly classified samples.
+        - **Precision**: The proportion of true positive predictions among all positive predictions.
+        - **Recall**: The proportion of true positive predictions among all actual positive cases.
+        - **F1-Score**: The harmonic mean of precision and recall.
+        - **ROC and AUC**: Metrics used to evaluate classification models.
+
+        **Example**: Using a confusion matrix to evaluate the performance of a sentiment analysis model.
+        """)
+
+    elif lifecycle_option == "Deployment":
+        st.write("""
+        #### 6. Deployment
+        Once the model is trained and evaluated, it is deployed to production for real-world use. This might include integration with applications like chatbots, recommendation systems, or text summarization tools.
+        - **Monitoring**: Continuous monitoring to ensure that the model performs well over time.
+        - **Retraining**: The model might need to be retrained periodically as new data becomes available.
+
+        **Example**: Deploying a chatbot powered by an NLP model to assist users on a website.
+        """)
+
+# Content for "NLP Techniques"
+elif st.session_state.selected_page == "NLP Techniques":
+    technique_option = sidebar.radio("Select NLP Technique:", [
+        "Tokenization",
+        "Stop Words Removal",
+        "Lemmatization",
+        "Stemming",
+        "Bag of Words (BoW)",
+        "TF-IDF",
+        "Word Embeddings",
+        "Named Entity Recognition (NER)",
+        "Part-of-Speech (POS) Tagging",
+        "Sentiment Analysis"
+    ])
     
-    **Techniques**:
-    - Extractive Summarization
-    - Abstractive Summarization
-    """)
-
-elif selected_task_page == 'Part-of-Speech Tagging':
-    st.write("""
-    ### Part-of-Speech (POS) Tagging:
-    POS Tagging involves identifying the grammatical components of a sentence, such as nouns, verbs, adjectives, etc.
-    **Example**: Tagging words in a sentence: 'I am learning NLP' -> [('I', 'PRP'), ('am', 'VBP'), ('learning', 'VBG'), ('NLP', 'NN')]
-    
-    **Techniques**:
-    - Rule-based POS Tagging
-    - Machine Learning-based POS Tagging (e.g., HMM, CRF)
-    """)
-
-elif selected_task_page == 'Text Generation':
-    st.write("""
-    ### Text Generation:
-    Text Generation is the task of generating new, coherent text based on some input.
-    **Example**: Generating a paragraph based on a given topic or generating captions for images.
-    
-    **Techniques**:
-    - RNN (Recurrent Neural Networks)
-    - LSTM (Long Short-Term Memory)
-    - Transformer-based models (e.g., GPT-3)
-    """)
-
-elif selected_task_page == 'Text Similarity':
-    st.write("""
-    ### Text Similarity:
-    Text Similarity involves measuring the similarity between two pieces of text.
-    **Example**: Comparing two sentences to see if they convey the same meaning.
-    
-    **Techniques**:
-    - Cosine Similarity
-    - Jaccard Similarity
-    - Semantic-based methods (e.g., using embeddings like Word2Vec, BERT)
-    """)
+    if technique_option == "Tokenization":
+        st.write("""
+        #### 1. Tokenization
+        Tokenization is the process of splitting text into smaller units, such as words, sentences, or subwords. This is a key preprocessing step for many NLP tasks.
+        - **Example**: 
+          - Sentence: "Natural Language Processing is awesome!"
+          - Tokenized words: ["Natural", "Language", "Processing", "is", "awesome"]
+        """)
+
+    elif technique_option == "Stop Words Removal":
+        st.write("""
+        #### 2. Stop Words Removal
+        Stop words are commonly used words like "the", "is", "at", etc., that do not carry much information in many NLP tasks. Removing stop words helps reduce the dimensionality and noise in the data.
+        - **Example**: Removing "is" from the sentence "NLP is amazing!"
+        """)
+
+    elif technique_option == "Lemmatization":
+        st.write("""
+        #### 3. Lemmatization
+        Lemmatization is the process of converting words into their root or base form based on context. It is more sophisticated than stemming, as it considers the meaning of words.
+        - **Example**: "better" → "good", "running" → "run".
+        """)
+
+    elif technique_option == "Stemming":
+        st.write("""
+        #### 4. Stemming
+        Stemming is the process of reducing words to their root form by removing prefixes or suffixes. This technique may result in non-dictionary words.
+        - **Example**: "running" → "run", "happiness" → "happi".
+        """)
+
+    elif technique_option == "Bag of Words (BoW)":
+        st.write("""
+        #### 5. Bag of Words (BoW)
+        The Bag of Words model represents text as a set of individual words, disregarding grammar and word order but keeping multiplicity. It is a simple and widely used method for text representation.
+        - **Example**:
+          - Text: "I love NLP"
+          - BoW: {"I": 1, "love": 1, "NLP": 1}
+        """)
+
+    elif technique_option == "TF-IDF":
+        st.write("""
+        #### 6. TF-IDF (Term Frequency-Inverse Document Frequency)
+        TF-IDF helps determine the importance of a word in a document relative to the entire dataset. It reduces the weight of common words and increases the weight of rare but important words.
+        - **Example**: The word "data" might have a high TF-IDF score in a document about data analysis but a low score in a document about cooking.
+        """)
+
+    elif technique_option == "Word Embeddings":
+        st.write("""
+        #### 7. Word Embeddings
+        Word embeddings are vector representations of words that capture semantic relationships. Words with similar meanings have similar vectors. Common word embedding models include:
+        - **Word2Vec**
+        - **GloVe**
+        - **FastText**
+
+        **Example**: The words "king" and "queen" would have similar vector representations because they share semantic relationships.
+        """)
+
+    elif technique_option == "Named Entity Recognition (NER)":
+        st.write("""
+        #### 8. Named Entity Recognition (NER)
+        NER is the task of identifying named entities such as persons, organizations, locations, and dates in text. This technique is commonly used for information extraction.
+        - **Example**: "Barack Obama was born in Hawaii."
+          - Entities: ["Barack Obama" (Person), "Hawaii" (Location)]
+        """)
+
+    elif technique_option == "Part-of-Speech (POS) Tagging":
+        st.write("""
+        #### 9. Part-of-Speech (POS) Tagging
+        POS tagging involves assigning grammatical labels (such as noun, verb, adjective) to each word in a sentence.
+        - **Example**: "The cat sat on the mat."
+          - POS Tags: [("The", "DT"), ("cat", "NN"), ("sat", "VBD"), ("on", "IN"), ("the", "DT"), ("mat", "NN")]
+        """)
+
+    elif technique_option == "Sentiment Analysis":
+        st.write("""
+        #### 10. Sentiment Analysis
+        Sentiment analysis involves determining the sentiment of a piece of text, typically categorizing it as positive, negative, or neutral. This is commonly used for customer feedback and social media monitoring.
+        - **Example**: "I love this product!" → Positive Sentiment
+        """)