import streamlit as st
def generate_ml_blog():
    # Use a relative path or adjust the file path for your environment
    image_path = "./A_detailed_and_professional_illustration_represent.jpg"  # Place the image in the app directory
    try:
        image = Image.open(image_path)  # Load the image
        st.image(image, caption="Machine Learning Overview", use_column_width=True)
    except FileNotFoundError:
        st.error("Image not found. Please ensure the file exists in the correct directory.")
def introduction_to_ml():
    introduction_blog = '''
    ## Introduction to Machine Learning (ML)
    Machine Learning (ML) is a subset of Artificial Intelligence (AI) that enables computers to learn from data and make predictions or decisions without being explicitly programmed. It has revolutionized many industries and plays a crucial role in technologies such as self-driving cars, recommendation systems, and facial recognition.

    ### Types of Machine Learning
    There are three main types of machine learning:

    1. **Supervised Learning**:
        Supervised learning algorithms learn from labeled data. The model is trained using a dataset where the input data and the correct output are both provided. The goal is to learn a mapping from inputs to outputs. Examples include linear regression, logistic regression, and decision trees.

    2. **Unsupervised Learning**:
        In unsupervised learning, the algorithm is given data without any labeled outputs. The goal is to find hidden patterns or groupings in the data. Examples include clustering (e.g., K-means) and dimensionality reduction techniques (e.g., PCA).

    3. **Reinforcement Learning**:
        Reinforcement learning involves an agent that learns to make decisions by interacting with an environment to maximize a cumulative reward. It is widely used in robotics, game AI, and real-time decision-making systems.

    ### Popular Machine Learning Algorithms
    Some of the most commonly used ML algorithms include:

    - **Linear Regression**: A simple algorithm used for predicting continuous values.
    - **Logistic Regression**: Used for binary classification problems.
    - **Decision Trees**: A tree-like model used for both classification and regression tasks.
    - **K-Nearest Neighbors (KNN)**: A non-parametric method used for classification and regression.
    - **Support Vector Machines (SVM)**: A powerful classifier that works well for high-dimensional spaces.
    - **Neural Networks**: A set of algorithms, modeled after the human brain, that are used for complex tasks like image and speech recognition.

    #### Applications of Machine Learning
    Machine learning is used in a wide variety of fields, including:

    - **Healthcare**: ML is used for predicting diseases, recommending treatments, and analyzing medical data.
    - **Finance**: Used for fraud detection, algorithmic trading, and risk analysis.
    - **E-commerce**: ML powers recommendation systems, personalized marketing, and customer support chatbots.
    - **Self-driving Cars**: ML algorithms help autonomous vehicles navigate and make real-time decisions.

    ### Conclusion
    Machine learning continues to evolve, with new algorithms, techniques, and applications emerging regularly. As the amount of data grows and computational power increases, the potential of ML to impact industries and improve our daily lives is limitless.
    '''
    
    return introduction_blog
def supervised_learning():
    supervised = '''
    ### Supervised Learning
    Supervised learning algorithms learn from labeled data. The model is trained using a dataset where the input data and the correct output are both provided. The goal is to learn a mapping from inputs to outputs.
    
    **Example**: 
    - **Linear Regression**: Used to predict a continuous value, such as predicting house prices.
    ```python
    from sklearn.linear_model import LinearRegression
    X = [[1], [2], [3], [4], [5]]  # Features
    y = [1, 2, 2.5, 4, 5]  # Target
    model = LinearRegression()
    model.fit(X, y)
    predictions = model.predict([[6]])  # Predict for 6 hours of study
    ```
    '''
    return supervised

def unsupervised_learning():
    unsupervised = '''
    ### Unsupervised Learning
    In unsupervised learning, the algorithm is given data without any labeled outputs. The goal is to find hidden patterns or groupings in the data. Examples include clustering (e.g., K-means) and dimensionality reduction techniques (e.g., PCA).
    
    **Example**:
    - **K-Means Clustering**: Grouping data points into clusters based on similarity.
    ```python
    from sklearn.cluster import KMeans
    X = [[1, 2], [1.5, 1.8], [5, 8], [8, 8], [1, 0.6], [9, 11]]
    kmeans = KMeans(n_clusters=2)
    kmeans.fit(X)
    labels = kmeans.predict(X)
    ```
    '''
    return unsupervised

def reinforcement_learning():
    reinforcement = '''
    ### Reinforcement Learning
    Reinforcement learning involves an agent that learns to make decisions by interacting with an environment to maximize a cumulative reward. It is widely used in robotics, game AI, and real-time decision-making systems.
    
    **Example**: 
    - **Q-Learning**: A reinforcement learning algorithm where an agent learns to maximize rewards by updating Q-values.
    ```python
    import numpy as np
    Q = np.zeros((5, 5))  # Example Q-table for 5 states and 5 actions
    alpha = 0.1  # Learning rate
    gamma = 0.9  # Discount factor
    reward = 10
    state = 0
    action = 1
    next_state = 1
    Q[state, action] = Q[state, action] + alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])
    ```
    '''
    return reinforcement
def linear_regression():
    linear = '''
    ### Linear Regression
    Linear regression is used to predict a continuous value based on one or more input features. It finds the best-fit line to minimize the error between the predicted and actual values.

    **Example**: 
    - **Predicting House Prices**: Predict the price of a house based on its features such as size and location.
    ```python
    from sklearn.linear_model import LinearRegression
    X = [[1], [2], [3], [4], [5]]  # Features (e.g., years of experience)
    y = [1, 2, 2.5, 4, 5]  # Target (e.g., salary)
    model = LinearRegression()
    model.fit(X, y)
    predictions = model.predict([[6]])  # Predict for 6 years of experience
    ```
    '''
    return linear

def logistic_regression():
    logistic = '''
    ### Logistic Regression
    Logistic regression is used for binary classification tasks, where the goal is to predict one of two outcomes, such as pass/fail or spam/not spam.

    **Example**:
    - **Predicting Spam Emails**: Classifying emails as spam or not spam.
    ```python
    from sklearn.linear_model import LogisticRegression
    from sklearn.datasets import load_iris
    data = load_iris()
    X = data.data
    y = (data.target == 0).astype(int)  # Binary classification (class 0 vs others)
    model = LogisticRegression()
    model.fit(X, y)
    predictions = model.predict(X)
    ```
    '''
    return logistic

def decision_trees():
    decision = '''
    ### Decision Trees
    Decision trees split the data into subsets based on feature values, creating a tree-like model. It is used for both classification and regression tasks.

    **Example**:
    - **Classifying Iris Species**: A decision tree can be used to classify different species of Iris flowers.
    ```python
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.datasets import load_iris
    data = load_iris()
    X = data.data
    y = data.target
    model = DecisionTreeClassifier()
    model.fit(X, y)
    predictions = model.predict(X)
    ```
    '''
    return decision

def knn():
    knn = '''
    ### K-Nearest Neighbors (KNN)
    KNN is a simple, non-parametric algorithm that classifies data based on the majority vote of its nearest neighbors.

    **Example**:
    - **Classifying a Data Point**: Predict the class of a data point based on its nearest neighbors.
    ```python
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.datasets import load_iris
    data = load_iris()
    X = data.data
    y = data.target
    model = KNeighborsClassifier(n_neighbors=3)
    model.fit(X, y)
    predictions = model.predict(X)
    ```
    '''
    return knn

def svm():
    svm = '''
    ### Support Vector Machines (SVM)
    SVM is a powerful classifier that works well for high-dimensional data. It tries to find the hyperplane that best separates the data points of different classes.

    **Example**:
    - **Classifying Iris Flowers**: An SVM can be used to classify Iris flowers into different species.
    ```python
    from sklearn.svm import SVC
    from sklearn.datasets import load_iris
    data = load_iris()
    X = data.data
    y = data.target
    model = SVC(kernel='linear')
    model.fit(X, y)
    predictions = model.predict(X)
    ```
    '''
    return svm

def neural_networks():
    neural = '''
    ### Neural Networks
    Neural networks are modeled after the human brain, with layers of interconnected nodes (neurons) used for tasks like image and speech recognition.

    **Example**:
    - **Classifying Handwritten Digits**: A simple neural network can be used to classify digits from the MNIST dataset.
    ```python
    from sklearn.neural_network import MLPClassifier
    from sklearn.datasets import load_iris
    data = load_iris()
    X = data.data
    y = data.target
    model = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000)
    model.fit(X, y)
    predictions = model.predict(X)
    ```
    '''
    return neural



# Streamlit UI Components
st.title("Machine Learning Concepts")
generate_ml_blog()  # Call the function to display the image

# Display interactive elements if needed
st.sidebar.header("📚 Contents")
st.sidebar.markdown("""
- 🔍 [Introduction](#Introduction-to-Machine-Learning-ML)
- 🧠 [Types of Machine Learning](#Types-of-Machine-Learning)
    - 📊 [Supervised Learning](#Supervised-Learning)
    - 🔗 [Unsupervised Learning](#Unsupervised-Learning)
    - 🕹️ [Reinforcement Learning](#Reinforcement-Learning)
- 🚀 [Popular Algorithms](#Popular-Machine-Learning-Algorithms)
    - 🔧 [Linear Regression](#Linear-Regression)
    - ✔️ [Logistic Regression](#Logistic-Regression)
    - 🌳 [Decision Trees](#Decision-Trees)
    - 🔍 [K-Nearest Neighbors (KNN)](#K-Nearest-Neighbors-KNN)
    - ✂️ [Support Vector Machines (SVM)](#Support-Vector-Machines-SVM)
    - 🧠 [Neural Networks](#Neural-Networks)
""")

# Display content based on the sidebar selection

page = st.sidebar.radio("Select Section", [
    "Introduction",
    "Supervised Learning",
    "Unsupervised Learning",
    "Reinforcement Learning",
    "Linear Regression",
    "Logistic Regression",
    "Decision Trees",
    "K-Nearest Neighbors (KNN)",
    "Support Vector Machines (SVM)",
    "Neural Networks"
])
if page == "Introduction":
     st.markdown("<h1 style='text-align: center; color: orange;'>Machine Learning (ML)</h1>", unsafe_allow_html=True)
     st.markdown("<h2 style='text-align: center; color: orange;'>Introduction</h2>", unsafe_allow_html=True)
     st.markdown(introduction_to_ml())
elif page == "Supervised Learning":
    st.markdown(supervised_learning())
elif page == "Unsupervised Learning":
    st.markdown(unsupervised_learning())
elif page == "Reinforcement Learning":
    st.markdown(reinforcement_learning())
elif page == "Linear Regression":
    st.markdown(linear_regression())
elif page == "Logistic Regression":
    st.markdown(logistic_regression())
elif page == "Decision Trees":
    st.markdown(decision_trees())
elif page == "K-Nearest Neighbors (KNN)":
    st.markdown(knn())
elif page == "Support Vector Machines (SVM)":
    st.markdown(svm())
elif page == "Neural Networks":
    st.markdown(neural_networks())