import streamlit as st

def main():
    st.title("Step 1: Problem Statement Definition 	:mag:")

    st.markdown(
        """
        Every successful NLP project begins with a **clear and well-defined problem statement**. This step lays the groundwork by identifying what you aim to solve, why it matters, and how you plan to approach it.
        
        A well-defined problem statement keeps your project focused and aligned with its goals.
        """
    )
    st.divider()

    # Section 1: Understand the Business or Use Case
    st.subheader("1. Understand the Business or Use Case 	:globe_with_meridians:")
    st.write(
        """
        Before jumping into solutions, take time to **understand the context** of the problem. Whether you're building a chatbot, performing sentiment analysis, or classifying text, you must align your project with the **real-world needs** of the business or end-users.
        """
    )
    st.markdown(
        """
        **Steps to Understand the Use Case:**
        - Ask **what problem** you are solving.
        - Determine **who benefits** from the solution (users, stakeholders).
        - Identify **why it matters**: What value does solving this problem provide?

        **Example:**
        - Business Problem: "Customers struggle to get quick answers on our website."
        - NLP Solution: Build a **customer support chatbot** to automate responses to common queries.
        """
    )
    st.divider()

    # Section 2: Define the Scope
    st.subheader("2. Define the Scope 	:sunrise_over_mountains:")
    st.write(
        """
        Clearly defining the **scope** of your problem is critical to avoid unnecessary complexity and keep the project manageable.
        
        Scope helps you identify **what's included** in the problem and what isn't.
        """
    )
    st.markdown(
        """
        **Questions to Define Scope:**
        - What **specific goals** are we targeting? (e.g., classify sentiment as positive or negative)
        - Are there any **limitations**? (e.g., only working with English text)
        - What **data sources** are needed? (e.g., customer reviews, social media posts)

        **Example:**
        - Problem Scope: "Analyze customer reviews to detect positive, negative, or neutral sentiments for English-language text only."
        """
    )
    st.divider()

    # Section 3: Identify Key Metrics
    st.subheader("3. Identify Key Metrics 	:1234:")
    st.write(
        """
        To evaluate the success of your NLP project, define **key metrics** that measure performance and ensure your model meets expectations.
        
        Metrics provide a way to **quantify progress** and compare different approaches.
        """
    )
    st.markdown(
        """
        **Common NLP Metrics:**
        - **Accuracy**: Proportion of correct predictions.
        - **F1-Score**: Balance between precision and recall.
        - **BLEU Score**: For evaluating text generation models.
        - **Perplexity**: To assess language models.

        **Example:**
        - "For a sentiment analysis model, aim for an F1-score of **85% or higher** on the test dataset."
        """
    )
    st.divider()

    # Section 4: Formulate the Problem as an NLP Task
    st.subheader("4. Formulate the Problem as an NLP Task :robot_face:")
    st.write(
        """
        Once the problem is defined and scoped, formulate it as a specific **NLP task**. This step bridges the gap between the problem statement and the technical solution.
        """
    )
    st.markdown(
        """
        **Common NLP Tasks:**
        - **Text Classification**: Categorize text into predefined classes (e.g., spam detection).
        - **Named Entity Recognition (NER)**: Identify entities like names, dates, or locations.
        - **Sentiment Analysis**: Detect emotions like positive, negative, or neutral sentiment.
        - **Text Summarization**: Summarize long documents into concise versions.

        **Example:**
        - Problem: "Categorize customer complaints into relevant topics."
        - NLP Task: **Text Classification**.
        """
    )
    st.divider()

    # Summary Section
    st.subheader("Summary::star2:")
    st.markdown(
        """
        Defining the problem statement involves:

        1. **Understanding the Use Case**: Align with real-world needs.
        2. **Defining the Scope**: Set clear boundaries for the project.
        3. **Identifying Key Metrics**: Quantify success with appropriate measures.
        4. **Formulating the Problem**: Map it to a specific NLP task.

        **Friendly Tip :bulb::**
        A clear problem statement ensures your project stays focused, measurable, and achievable. Spend time here to avoid confusion later in the NLP pipeline!
        """
    )

    st.divider()

main()