Update app.py

app.py

@@ -2,7 +2,14 @@ import streamlit as st
 
 # Function to generate ML blog content
 def generate_ml_blog():
-    blog = '''
+    # Display an ML-related image
+    image = Image.open(r"C:\Users\user\Downloads\A_detailed_and_professional_illustration_represent.jpg")  # Replace with your image path
+    blog=st.image(image, caption="Machine Learning Overview", use_column_width=True)
+        
+    return blog
+
+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.
 
@@ -40,16 +47,185 @@ def generate_ml_blog():
     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 blog
+    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
 
-# Streamlit UI Components
+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
 
-st.markdown("<h1 style='text-align: center; color: orange;'>Machine Learning (ML)</h1>", unsafe_allow_html=True)
+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
 
-st.markdown("<h2 style='text-align: center; color: orange;'>Introduction</h2>", unsafe_allow_html=True)
+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.markdown(generate_ml_blog())
 
+
 # Display interactive elements if needed
 st.sidebar.header("📚 Contents")
 st.sidebar.markdown("""
@@ -67,4 +243,41 @@ st.sidebar.markdown("""
     - 🧠 [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())