pages/The intro to NLP.py

import streamlit as st

# Streamlit App Title and Introduction
st.title("Introduction to Natural Language Processing (NLP)")

st.write(
    """
    **Natural Language Processing (NLP)** is a fascinating branch of **Artificial Intelligence (AI)** 
    that enables computers to understand, interpret, and interact with human language. 
    It bridges the gap between human communication (natural language) and machine processing, 
    unlocking the potential to derive meaningful insights from text or speech data.
    """
)

# Importance of NLP Section
st.header("Why is NLP Important?")
st.write(
    """
    In today's digital age, textual data is one of the most abundant and valuable sources of information. However, unlike numerical 
    or visual data, text data is unstructured and requires advanced techniques for processing. NLP is the key to unlocking its potential.
    """
)

if st.button("Learn about NLP Applications"):
    st.write(
        """
        NLP powers many applications that impact our daily lives. Here are a few examples:
        - **Language Translation**: Tools like Google Translate help break language barriers.
        - **Sentiment Analysis**: AI systems extract emotions and opinions from customer reviews or social media.
        - **Chatbots and Virtual Assistants**: Interact naturally with AI systems like Alexa and Siri.
        - **Text Summarization**: Condense lengthy documents into concise summaries.
        """
    )
st.markdown("---")
# NLP Workflow Section
st.header("Understanding the NLP Workflow")
st.write(
    """
    NLP involves a systematic process to transform unstructured language data into actionable insights. Here's a detailed explanation of the workflow:

    1. **Input**: This is where raw text or speech data (e.g., customer reviews, transcripts) enters the pipeline. It can be in various forms such as text files, JSON, or audio recordings.

    2. **Preprocessing**: The initial and crucial step where raw data is cleaned and transformed to make it suitable for analysis. Key tasks include:
        - **Removing Stopwords**: Filtering out common words like "is," "the," "and," etc., that don't contribute much meaning.
        - **Tokenization**: Breaking down text into smaller units like words or sentences.
        - **Normalization**: Converting text to lowercase or standardizing formats.
        - **Stemming and Lemmatization**: Reducing words to their root form (e.g., "running" to "run").

    3. **Feature Extraction**: Transforming text into a machine-readable format. Techniques include:
        - **Bag of Words (BoW)**: Representing text as a collection of word frequencies.
        - **TF-IDF (Term Frequency-Inverse Document Frequency)**: Evaluating word importance in a document relative to a collection.
        - **Word Embeddings**: Generating dense vector representations for semantic understanding (e.g., Word2Vec, GloVe).

    4. **Modeling**: Applying algorithms to analyze and predict outcomes based on text data. Examples include:
        - Sentiment analysis using Logistic Regression or Naive Bayes.
        - Text classification with Support Vector Machines (SVMs).
        - Deep learning models like LSTMs or Transformers for advanced tasks like language generation.

    5. **Output**: The final result can be structured insights such as sentiment scores, summarized text, or even actionable decisions.
    """
)

st.markdown("---")

# Highlighting Python in NLP Section
st.header("Why Python for NLP?")
st.write(
    """
    Python is the go-to programming language for NLP, offering powerful libraries and tools that simplify the process of text processing and machine learning.
    """
)

library = st.radio("Choose a library to learn more about:", ["NLTK - Classic NLP", "spaCy - Production Ready", "Transformers - Deep Learning"])

if library == "NLTK - Classic NLP":
    st.write(
        """
        **NLTK (Natural Language Toolkit)**:
        - Comprehensive library for natural language processing.
        - Offers tools for tokenization, parsing, stemming, and sentiment analysis.
        - Example:
        ```python
        import nltk
        nltk.download('punkt')
        from nltk.tokenize import word_tokenize
        text = "Natural Language Processing is fascinating!"
        tokens = word_tokenize(text)
        print(tokens)  # Output: ['Natural', 'Language', 'Processing', 'is', 'fascinating', '!']
        ```
        """
    )
elif library == "spaCy - Production Ready":
    st.write(
        """
        **spaCy**:
        - An industrial-strength NLP library designed for production use.
        - Features pre-trained models for various languages and tasks like Named Entity Recognition (NER).
        - Example:
        ```python
        import spacy
        nlp = spacy.load('en_core_web_sm')
        text = "Apple is looking at buying U.K. startup for $1 billion."
        doc = nlp(text)
        for entity in doc.ents:
            print(entity.text, entity.label_)  # Output: Apple ORG, U.K. GPE, $1 billion MONEY
        ```
        """
    )
elif library == "Transformers - Deep Learning":
    st.write(
        """
        **Transformers (Hugging Face)**:
        - Provides state-of-the-art pre-trained models for tasks like text generation, translation, and question answering.
        - Utilizes models like BERT, GPT, and T5.
        - Example:
        ```python
        from transformers import pipeline
        summarizer = pipeline("summarization")
        text = "Natural Language Processing (NLP) enables computers to understand human language. It is used in chatbots, translation, and more."
        summary = summarizer(text, max_length=30, min_length=10, do_sample=False)
        print(summary)
        ```
        """
    )

st.markdown("---")

# Wrap-Up Section
st.header("Key Takeaways")
st.write(
    """
    Natural Language Processing (NLP) is transforming the way we interact with machines and make sense of textual data. With Python's robust libraries and a solid understanding of the NLP workflow, the possibilities are endless!
    """
)