Update app.py

app.py

@@ -5,7 +5,7 @@ st.title("NLP Theory Blog")
 
 # Sidebar for navigation
 st.sidebar.title("Navigation")
-pages = ["Introduction to NLP", "NLP Techniques", "NLP Life Cycle"]
+pages = ["Introduction to NLP", "NLP Life Cycle", "NLP Techniques"]
 page = st.sidebar.radio("Go to:", pages)
 
 # Content for each page
@@ -24,120 +24,191 @@ if page == "Introduction to NLP":
         NLP combines computational linguistics with machine learning and deep learning techniques to process language.
     """)
 
+elif page == "NLP Life Cycle":
+    st.header("NLP Life Cycle")
+    
+    st.subheader("1. Problem Definition")
+    st.write("""
+        In this phase, the problem you're trying to solve with NLP is defined. Examples include:
+        - Sentiment analysis
+        - Named entity recognition (NER)
+        - Text classification
+        - Machine translation
+        - Language generation
+    """)
+
+    st.subheader("2. Data Collection")
+    st.write("""
+        Gather relevant textual data. Sources include:
+        - Web scraping (e.g., using BeautifulSoup or Scrapy)
+        - APIs (e.g., Twitter API)
+        - Pre-existing datasets (e.g., Kaggle, UCI repositories)
+        - User-generated content (e.g., reviews, social media)
+    """)
+
+    st.subheader("3. Data Preprocessing")
+    st.write("""
+        Prepare the data for modeling by performing tasks such as:
+        - Text cleaning (removing unnecessary characters, punctuation)
+        - Tokenization (splitting text into words/sentences)
+        - Stopword removal
+        - Stemming or lemmatization
+        - Part-of-speech tagging
+    """)
+
+    st.subheader("4. Feature Engineering")
+    st.write("""
+        Convert text data into numerical form for model consumption:
+        - Bag of Words (BoW)
+        - TF-IDF (Term Frequency-Inverse Document Frequency)
+        - Word embeddings (Word2Vec, GloVe)
+        - Contextual embeddings (BERT, GPT)
+    """)
+
+    st.subheader("5. Modeling")
+    st.write("""
+        Train machine learning or deep learning models using the preprocessed text data:
+        - Supervised learning (e.g., Logistic Regression, SVM)
+        - Unsupervised learning (e.g., K-means clustering)
+        - Deep learning (e.g., RNNs, LSTMs, BERT)
+    """)
+
+    st.subheader("6. Model Evaluation")
+    st.write("""
+        Evaluate the model's performance using metrics like:
+        - Accuracy
+        - Precision, Recall, F1-Score
+        - Confusion Matrix
+        - Cross-validation
+    """)
+
+    st.subheader("7. Model Optimization")
+    st.write("""
+        Improve model performance by:
+        - Hyperparameter tuning (e.g., grid search)
+        - Regularization (e.g., L2 regularization, dropout)
+        - Ensemble methods (e.g., Random Forest, XGBoost)
+    """)
+
+    st.subheader("8. Model Deployment")
+    st.write("""
+        Deploy the trained model into production:
+        - Expose the model via APIs (using Flask or FastAPI)
+        - Integrate with applications (e.g., chatbots, recommendation systems)
+        - Monitor the model's performance
+    """)
+
+    st.subheader("9. Post-Deployment Maintenance")
+    st.write("""
+        Keep the model updated with new data:
+        - Retraining the model with fresh data
+        - Error analysis and model refinement
+        - Collecting user feedback for continuous improvement
+    """)
+
+    st.subheader("10. End-User Interaction")
+    st.write("""
+        Present the model's results in an understandable way:
+        - Data visualization (e.g., charts, word clouds)
+        - Interactive dashboards (e.g., using Streamlit or Dash)
+        - Interface design (e.g., web or mobile apps)
+    """)
+
 elif page == "NLP Techniques":
     st.header("Common NLP Techniques")
+
+    st.subheader("1. Tokenization")
     st.write("""
-        NLP involves several techniques for processing and analyzing text and speech data. Here are some key techniques:
+        Tokenization is the process of breaking text into smaller units like words, phrases, or sentences. This is a crucial first step in many NLP tasks.
 
-        1. **Tokenization:** Breaking text into smaller units like words or sentences.
-        2. **Stopword Removal:** Eliminating common words (e.g., 'the', 'is') that may not contribute to meaning.
-        3. **Stemming and Lemmatization:** Reducing words to their base or root form.
-        4. **Part-of-Speech (POS) Tagging:** Identifying grammatical parts of speech in a text.
-        5. **Named Entity Recognition (NER):** Extracting named entities like people, organizations, and locations.
-        6. **Sentiment Analysis:** Determining the sentiment (positive, negative, neutral) of a text.
-        7. **Text Summarization:** Producing a summary of a longer text.
-        8. **Machine Translation:** Translating text from one language to another.
+        **Example:**
+        Text: "Natural Language Processing is amazing!"
+        Tokenized text: ["Natural", "Language", "Processing", "is", "amazing"]
 
-        These techniques are often used in combination to build sophisticated NLP applications.
+        Tokenization helps in making the text more manageable and ready for further processing.
     """)
 
-elif page == "NLP Life Cycle":
-    # NLP Life Cycle Page with Sub-navigation
-    st.header("NLP Life Cycle")
+    st.subheader("2. Stopword Removal")
+    st.write("""
+        Stopword removal involves eliminating common words (e.g., 'the', 'is', 'in') that may not contribute significantly to the meaning of the text.
+
+        **Example:**
+        Text: "The quick brown fox jumps over the lazy dog."
+        After stopword removal: ["quick", "brown", "fox", "jumps", "lazy", "dog"]
+
+        Removing stopwords helps reduce the size of the dataset and focuses on meaningful terms.
+    """)
+
+    st.subheader("3. Stemming and Lemmatization")
+    st.write("""
+        Both stemming and lemmatization are techniques for reducing words to their base or root form.
+
+        - **Stemming**: Cuts off prefixes or suffixes. For example, "running" becomes "run".
+        - **Lemmatization**: Uses a dictionary to find the base form of a word. For example, "better" becomes "good".
+
+        **Example:**
+        Word: "running"
+        - Stemming: "run"
+        - Lemmatization: "run"
+    """)
+
+    st.subheader("4. Part-of-Speech (POS) Tagging")
+    st.write("""
+        Part-of-speech tagging assigns a part-of-speech label (e.g., noun, verb, adjective) to each word in a sentence.
+
+        **Example:**
+        Text: "The cat sat on the mat."
+        POS tags: [("The", "DT"), ("cat", "NN"), ("sat", "VBD"), ("on", "IN"), ("the", "DT"), ("mat", "NN")]
+
+        POS tagging is useful for tasks like Named Entity Recognition (NER) or syntactic parsing.
+    """)
+
+    st.subheader("5. Named Entity Recognition (NER)")
+    st.write("""
+        Named Entity Recognition (NER) is the task of identifying named entities such as people, organizations, locations, etc., in text.
+
+        **Example:**
+        Text: "Apple is looking to buy a startup in London."
+        NER output: [("Apple", "ORG"), ("London", "LOC")]
 
-    # Sidebar navigation for NLP Life Cycle sub-pages
-    life_cycle_pages = ["Problem Definition", "Data Collection", "Data Preprocessing", "Feature Engineering", 
-                        "Modeling", "Model Evaluation", "Model Optimization", "Model Deployment", 
-                        "Post-Deployment Maintenance", "End-User Interaction"]
-    life_cycle_page = st.sidebar.radio("Select a step in the NLP Life Cycle:", life_cycle_pages)
-
-    # Content for each sub-page of NLP Life Cycle
-    if life_cycle_page == "Problem Definition":
-        st.write("""
-            In this phase, the problem you're trying to solve with NLP is defined. Examples include:
-            - Sentiment analysis
-            - Named entity recognition (NER)
-            - Text classification
-            - Machine translation
-            - Language generation
-        """)
-
-    elif life_cycle_page == "Data Collection":
-        st.write("""
-            Gather relevant textual data. Sources include:
-            - Web scraping (e.g., using BeautifulSoup or Scrapy)
-            - APIs (e.g., Twitter API)
-            - Pre-existing datasets (e.g., Kaggle, UCI repositories)
-            - User-generated content (e.g., reviews, social media)
-        """)
-
-    elif life_cycle_page == "Data Preprocessing":
-        st.write("""
-            Prepare the data for modeling by performing tasks such as:
-            - Text cleaning (removing unnecessary characters, punctuation)
-            - Tokenization (splitting text into words/sentences)
-            - Stopword removal
-            - Stemming or lemmatization
-            - Part-of-speech tagging
-        """)
-
-    elif life_cycle_page == "Feature Engineering":
-        st.write("""
-            Convert text data into numerical form for model consumption:
-            - Bag of Words (BoW)
-            - TF-IDF (Term Frequency-Inverse Document Frequency)
-            - Word embeddings (Word2Vec, GloVe)
-            - Contextual embeddings (BERT, GPT)
-        """)
-
-    elif life_cycle_page == "Modeling":
-        st.write("""
-            Train machine learning or deep learning models using the preprocessed text data:
-            - Supervised learning (e.g., Logistic Regression, SVM)
-            - Unsupervised learning (e.g., K-means clustering)
-            - Deep learning (e.g., RNNs, LSTMs, BERT)
-        """)
-
-    elif life_cycle_page == "Model Evaluation":
-        st.write("""
-            Evaluate the model's performance using metrics like:
-            - Accuracy
-            - Precision, Recall, F1-Score
-            - Confusion Matrix
-            - Cross-validation
-        """)
-
-    elif life_cycle_page == "Model Optimization":
-        st.write("""
-            Improve model performance by:
-            - Hyperparameter tuning (e.g., grid search)
-            - Regularization (e.g., L2 regularization, dropout)
-            - Ensemble methods (e.g., Random Forest, XGBoost)
-        """)
-
-    elif life_cycle_page == "Model Deployment":
-        st.write("""
-            Deploy the trained model into production:
-            - Expose the model via APIs (using Flask or FastAPI)
-            - Integrate with applications (e.g., chatbots, recommendation systems)
-            - Monitor the model's performance
-        """)
-
-    elif life_cycle_page == "Post-Deployment Maintenance":
-        st.write("""
-            Keep the model updated with new data:
-            - Retraining the model with fresh data
-            - Error analysis and model refinement
-            - Collecting user feedback for continuous improvement
-        """)
-
-    elif life_cycle_page == "End-User Interaction":
-        st.write("""
-            Present the model's results in an understandable way:
-            - Data visualization (e.g., charts, word clouds)
-            - Interactive dashboards (e.g., using Streamlit or Dash)
-            - Interface design (e.g., web or mobile apps)
-        """)
+        NER is crucial for information extraction tasks like identifying company names or locations in a text.
+    """)
+
+    st.subheader("6. Sentiment Analysis")
+    st.write("""
+        Sentiment Analysis is the process of determining the sentiment expressed in a text, typically classified as positive, negative, or neutral.
+
+        **Example:**
+        Text: "I love this phone, it's amazing!"
+        Sentiment: Positive
+
+        Sentiment analysis is widely used in social media monitoring, customer feedback analysis, and product reviews.
+    """)
+
+    st.subheader("7. Text Summarization")
+    st.write("""
+        Text summarization generates a shorter version of a given text, maintaining the most important information.
+
+        - **Extractive summarization**: Extracts important sentences from the original text.
+        - **Abstractive summarization**: Generates new sentences to summarize the original content.
+
+        **Example (Extractive):**
+        Original text: "Natural Language Processing is a subfield of AI. It deals with how computers understand human language."
+        Summarized: "NLP is a subfield of AI that deals with human language."
+
+        Text summarization helps in condensing large documents into key points.
+    """)
+
+    st.subheader("8. Machine Translation")
+    st.write("""
+        Machine Translation is the task of translating text from one language to another.
+
+        **Example:**
+        Text in English: "Hello, how are you?"
+        Translated text in Spanish: "Hola, ¿cómo estás?"
+
+        Machine translation systems like Google Translate use deep learning models to produce translations.
+    """)
 
 # Footer
 st.sidebar.write("---")