Update app.py

app.py

@@ -110,31 +110,34 @@ elif st.session_state.selected_page == "NLP Lifecycle":
     elif lifecycle_option == "Problem Definition":
         st.write("""
         #### 1. Problem Definition
-        Problem definition is the first stage of the NLP lifecycle. It involves identifying the goal and understanding the problem that NLP can solve.
-        - **Key Questions**:
-            - What is the main objective of the analysis?
-            - What type of text data is being handled (e.g., reviews, social media, documents)?
-            - What output is expected (e.g., sentiment score, summary, classification)?
-        **Example**: Define whether the goal is to classify customer reviews as positive or negative or to extract key topics from product reviews.
+        - The first step in the NLP lifecycle is defining the problem. This means understanding the goal and figuring out how NLP can help solve the problem.
+        - Based on the problem, you will need to gather the data.
+        - **To better understand the problem, consider asking questions such as**:
+            - What is the main goal of this analysis?
+            - What kind of text data are we working with (e.g., reviews, social media posts, documents)?
+            - What do we want the output to be (e.g., sentiment score, summary, or classification)?
+    
+        **Example of a problem statement**: The goal could be to classify customer reviews as either positive or negative, or to find the main topics in product reviews.
         """)
 
-    
     elif 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)
+       #### 2. Data Collection
+       Data collection is the second step in the NLP lifecycle. It involves gathering data from various sources based on the problem statement, so it can be analyzed and processed.
+       - **Sources for data collection**:
+            - The data should be collected based on a clear understanding of the problem statement.
+            - From datasets available on websites like Kaggle.
+            - Through APIs.
+            - Manually, when needed.
+            - In most cases, data is collected through websites or APIs, but manual collection may be required in rare situations.
+
 
         **Example**: Scraping customer reviews from Amazon to analyze sentiment and feedback about a product.
         """)
 
     elif lifecycle_option == "Text Preprocessing":
         st.write("""
-        #### 2. Text Preprocessing
+        #### 3. 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.
@@ -150,7 +153,7 @@ elif st.session_state.selected_page == "NLP Lifecycle":
 
     elif lifecycle_option == "Text Representation":
         st.write("""
-        #### 3. Text Representation
+        #### 4. 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.
@@ -163,7 +166,7 @@ elif st.session_state.selected_page == "NLP Lifecycle":
 
     elif lifecycle_option == "Model Training":
         st.write("""
-        #### 4. Model Training
+        #### 5. 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.
@@ -174,7 +177,7 @@ elif st.session_state.selected_page == "NLP Lifecycle":
 
     elif lifecycle_option == "Evaluation":
         st.write("""
-        #### 5. Evaluation
+        #### 6. 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.
@@ -187,7 +190,7 @@ elif st.session_state.selected_page == "NLP Lifecycle":
 
     elif lifecycle_option == "Deployment":
         st.write("""
-        #### 6. Deployment
+        #### 7. 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.