Activity-7: Exploring Machine Learning Basics

This activity introduces the fundamentals of Machine Learning (ML), its necessity
in the AI domain, application areas, and basic learning techniques. Students will
gain insights into theory and practical aspects through questions and programming
tasks.

1. Introduction to Machine Learning

Machine Learning (ML) is a subfield of Artificial Intelligence (AI) that enables systems to learn
from data and improve their performance without explicitly being programmed.

2. Why Do We Need Machine Learning?

1. Data Growth: Massive amounts of data are generated daily; ML helps analyze and
derive insights.
2. Complexity: Traditional programming fails with problems like pattern recognition or
dynamic decision-making.
3. Automation: ML enables intelligent automation, reducing human intervention in
repetitive tasks.
4. Scalability: ML models can adapt to growing data and requirements efficiently.

3. Application Domains of Machine Learning

1. Healthcare: Disease diagnosis, drug discovery, patient management.

2. Finance: Fraud detection, risk assessment, stock market prediction.
3. Retail: Customer behavior prediction, recommendation systems.
4. Autonomous Systems: Self-driving cars, robotics.
5. Natural Language Processing (NLP): Language translation, sentiment analysis,
chatbots.

4. Basic Learning Techniques in Machine Learning

1. Supervised Learning:
o Uses labeled data (input-output pairs).
o Common algorithms: Linear Regression, Decision Trees, Neural Networks.
o Example: Predicting house prices based on historical data.
 2. Unsupervised Learning:
o Uses unlabeled data; the system identifies patterns.
o Common algorithms: K-Means Clustering, Principal Component Analysis (PCA).
o Example: Customer segmentation for targeted marketing.
3. Reinforcement Learning:
o Agents learn through trial and error, receiving rewards or penalties.
o Example: Training robots for tasks or game-playing AI.

5. Example: Predicting House Prices

Python Code (Supervised Learning using Linear Regression):

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Dataset: Features (size in sq ft) and Labels (price in $1000s)

X = np.array([[1200], [1500], [1700], [2000], [2200]])
y = np.array([300, 350, 400, 450, 500])

# Splitting data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)

# Training model
model = LinearRegression()
model.fit(X_train, y_train)

# Predictions
y_pred = model.predict(X_test)

# Evaluate
print("Mean Squared Error:", mean_squared_error(y_test, y_pred))
print("Predicted Prices:", y_pred)

Questions

1. What are the three main types of machine learning? Briefly explain each with an
example.

Answer 1: Machine learning (ML) is a field of artificial intelligence that enables systems to learn
from data and improve over time without being explicitly programmed. There are three main
types of machine learning:

1. Supervised Learning
 In supervised learning, the algorithm learns from labeled training data, which means each
training example is paired with an output label. The goal is to learn a mapping from
inputs to outputs so that the model can predict the labels for unseen data.

Example: Spam Detection

 Scenario: Classifying emails as spam or not spam.

 Data: A dataset containing emails labeled as "spam" or "not spam."
 Approach: The algorithm learns from the labeled emails and can then predict whether
new emails are spam based on patterns it has identified.

2. Unsupervised Learning

Unsupervised learning involves training an algorithm on data that has no labeled

responses. The goal is to find hidden patterns or intrinsic structures in the data.

Example: Customer Segmentation

 Scenario: Grouping customers based on purchasing behavior.

 Data: A dataset containing customer purchase histories.
 Approach: The algorithm clusters customers into distinct groups based on similarities in
their purchase behavior, which can help in targeted marketing.

3. Reinforcement Learning

In reinforcement learning, an agent learns to make decisions by performing actions in an

environment to maximize cumulative reward. The agent receives feedback in the form of
rewards or penalties and adjusts its actions to achieve the best long-term outcome.

Example: Game Playing

 Scenario: A computer program learning to play a game like chess or Go.

 Data: The game environment and rules.
 Approach: The agent makes moves in the game, receives feedback based on the outcome
(e.g., winning or losing points), and learns to improve its strategy over time to maximize
its chances of winning.

These three types of machine learning each have unique applications and advantages,
making them suitable for different kinds of problems and data.

2. Explain the importance of Machine Learning in solving real-world problems.

Provide two examples from different application domains.

Answer 2: Machine learning (ML) is a transformative technology with the potential to solve a
wide range of real-world problems. It leverages algorithms and statistical models to analyze and
 interpret complex data, making predictions or decisions without explicit human instructions.
Here are two examples from different application domains that showcase the importance of ML:

Example 1: Healthcare - Predictive Diagnostics

Problem: Early detection of diseases such as cancer can significantly improve patient
outcomes, but traditional diagnostic methods can be slow and sometimes inaccurate.

Solution: Machine learning models, particularly those based on deep learning, can
analyze medical images (like X-rays, MRIs, and CT scans) to detect abnormalities with
high accuracy. These models are trained on vast datasets of medical images, learning to
identify patterns indicative of diseases.

Impact: ML-based predictive diagnostics can lead to earlier detection of conditions like
breast cancer, enabling timely intervention and treatment. This reduces mortality rates
and improves the quality of life for patients.

Example 2: Finance - Fraud Detection

Problem: Financial fraud, including credit card fraud and fraudulent transactions, poses
significant risks to both consumers and financial institutions.

Solution: Machine learning algorithms can analyze transaction data in real time to detect
unusual patterns that may indicate fraudulent activity. These models learn from historical
transaction data, identifying subtle indicators of fraud that traditional rule-based systems
might miss.

Impact: Implementing ML for fraud detection enhances security by quickly flagging and
preventing fraudulent transactions. This protects consumers' financial assets and reduces
losses for banks and financial institutions.

Importance of Machine Learning:

1. Efficiency and Scalability: ML algorithms can process and analyze large volumes of
data far more quickly than human analysts, making them ideal for applications requiring
real-time decision-making.
2. Accuracy and Precision: By learning from data, ML models can achieve high levels of
accuracy, often outperforming traditional methods in tasks like image recognition, speech
processing, and predictive analytics.
3. Adaptability: ML systems can adapt to new data and evolving patterns, continuously
improving their performance over time. This adaptability is crucial in dynamic fields
such as cybersecurity and personalized medicine.

In summary, machine learning empowers various industries to solve complex problems

more efficiently and effectively, leading to significant advancements and improvements
in many areas of our daily lives.
3. Modify the provided Python code to include an additional feature (e.g., the number
of bedrooms) and train the model again. What is the new Mean Squared Error?

Answer 3: To include an additional feature (such as the number of bedrooms) and retrain the
model, we need to modify the dataset to include this new feature and adjust the model
accordingly. This will involve adding an extra column for the number of bedrooms to the input
features (X).

Steps to Modify the Code:

1. Add the Number of Bedrooms as a New Feature: Modify the X array to include an
additional column that represents the number of bedrooms for each data point.
2. Train the Model Again: Fit the linear regression model with the updated dataset.
3. Evaluate the Model: Calculate the Mean Squared Error (MSE) using the test set and
print the predicted prices.

Modified Code:

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

# Dataset: Features (size in sq ft and number of bedrooms) and Labels (price in $1000s)

# Add a new column for the number of bedrooms

X = np.array([[1200, 3], [1500, 3], [1700, 4], [2000, 4], [2200, 5]])

y = np.array([300, 350, 400, 450, 500])

# Splitting data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Training model
 model = LinearRegression()

model.fit(X_train, y_train)

# Predictions

y_pred = model.predict(X_test)

# Evaluate

print("Mean Squared Error:", mean_squared_error(y_test, y_pred))

print("Predicted Prices:", y_pred)

Explanation of Changes:

1. Updated Dataset:
o X now contains two features: the size of the house in square feet and the number
of bedrooms. For example, the first entry [1200, 3] means a house of 1200 square
feet with 3 bedrooms.
2. Training the Model:
o The linear regression model is now trained with the updated dataset (X_train with
two features).
3. Evaluation:
o The Mean Squared Error (MSE) is calculated based on the predictions made by
the model.

What is Mean Squared Error (MSE)?

The MSE is a measure of how well the model's predictions match the actual values. It is
calculated as the average squared differences between the predicted and actual values.
Lower MSE values indicate better model performance.

Expected Outcome:

After running the modified code, the model will take into account both the house size and
the number of bedrooms when predicting the price. The MSE will likely change
compared to the original model, as the inclusion of the number of bedrooms provides
more information for the model to learn from.

You can run this code in your local environment to get the updated MSE and predicted
prices. The output might look something like this:
 Mean Squared Error: <some_value>

Predicted Prices: [predicted_prices].

The exact value of the MSE and the predicted prices will depend on the dataset and the
model's learning from the two features.

4. Describe a problem in your area of interest that can be solved using Machine
Learning. Identify the data, learning type, and suitable algorithm.

Answer 4: Let's consider an interesting problem in the realm of environmental conservation:

predicting deforestation rates to take preventive actions.

Problem Description

Objective: Predict future deforestation rates in specific regions to implement effective

conservation strategies and mitigate environmental impact.

Data

To tackle this problem, we would need various types of data:

1. Satellite Imagery: High-resolution images of forested areas over time to detect changes
in forest cover.
2. Environmental Data: Information on climate conditions, soil types, and biodiversity in
the regions.
3. Socioeconomic Data: Data on human activities such as logging, agriculture,
urbanization, and their impact on forests.
4. Historical Data: Records of past deforestation rates and related events.

Learning Type

Supervised Learning: We will use labeled data where the target variable is the rate of
deforestation. The model will learn from historical data and predict future deforestation
rates based on input features.

Suitable Algorithm

1. Convolutional Neural Networks (CNNs): These are particularly effective for analyzing
satellite imagery to detect changes in forest cover over time. CNNs can learn spatial
hierarchies of features, making them ideal for image processing tasks.
2. Random Forest Regression: This algorithm can handle tabular data such as
environmental and socioeconomic factors. It is robust to overfitting and can handle the
complexity of the interactions between various input features.
3. Long Short-Term Memory (LSTM): For time-series analysis, LSTMs can capture
temporal dependencies in historical data and predict future trends in deforestation rates.
 Implementation Workflow

1. Data Collection and Preprocessing: Gather satellite imagery, environmental,

socioeconomic, and historical data. Preprocess the images (e.g., normalization, resizing)
and clean the tabular data (e.g., handling missing values).
2. Feature Engineering: Extract relevant features from the data. For satellite imagery, this
could include vegetation indices like NDVI (Normalized Difference Vegetation Index).
For tabular data, this could involve aggregating socioeconomic indicators.
3. Model Training: Train the selected algorithms (CNNs for imagery, Random Forest or
LSTM for tabular/time-series data) using historical data and validate their performance.
4. Model Evaluation: Evaluate the models using metrics such as Mean Absolute Error
(MAE) or Root Mean Squared Error (RMSE) for regression tasks. Assess the models'
ability to generalize to unseen data.
5. Prediction and Action: Use the trained models to predict future deforestation rates.
Based on the predictions, implement preventive measures like stricter regulations,
reforestation projects, and community engagement.

Example:

Imagine a region in the Amazon rainforest facing deforestation. By analyzing satellite

images over the past decade and combining this with climate data and records of logging
activities, we can train a model to predict which areas are at highest risk of future
deforestation. Conservationists can then focus their efforts on these high-risk areas to
prevent further damage.

This approach not only helps in early detection but also aids in making data-driven
decisions to protect our vital ecosystems. Machine learning thus plays a crucial role in
preserving our environment for future generations.

5. Write a Python program using K-Means Clustering to group students based on

their marks in three subjects. Assume appropriate data.

Answer 5: Let's create a Python program to use K-Means Clustering to group students based on
their marks in three subjects: Mathematics, Science, and English.

Step-by-Step Process:

1. Import Libraries: We'll use pandas for data handling and scikit-learn for the K-Means
clustering algorithm.
2. Create a DataFrame: We'll assume some sample data for student marks.
3. Apply K-Means Clustering: We'll cluster the students based on their marks.
4. Visualize Results: We'll use matplotlib to visualize the clusters.

Here's the complete Python program:

import pandas as pd
import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

# Sample data: Students' marks in Mathematics, Science, and English

data = {

'Student': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],

'Mathematics': [85, 92, 88, 75, 95, 70, 78, 85, 60, 72],

'Science': [90, 85, 80, 95, 89, 65, 88, 92, 75, 68],

'English': [88, 70, 85, 80, 78, 90, 82, 76, 88, 80]

# Create a DataFrame

df = pd.DataFrame(data)

# Extract the marks

X = df[['Mathematics', 'Science', 'English']]

# Apply K-Means Clustering

kmeans = KMeans(n_clusters=3)

df['Cluster'] = kmeans.fit_predict(X)

# Visualize the clusters

plt.scatter(df['Mathematics'], df['Science'], c=df['Cluster'], cmap='viridis')

 plt.xlabel('Mathematics')

plt.ylabel('Science')

plt.title('K-Means Clustering of Students based on Marks')

plt.colorbar(label='Cluster')

plt.show()

# Print the cluster assignment

print(df)

Explanation:

1. Import Libraries:
o pandas for handling the data.
o matplotlib for visualization.
o scikit-learn for the K-Means clustering algorithm.
2. Create a DataFrame:
o We assume some sample data for 10 students with their marks in Mathematics,
Science, and English.
3. Extract the Marks:
o We extract the marks into a variable X which we will use for clustering.
4. Apply K-Means Clustering:
o We create a KMeans object with 3 clusters and fit it to the data. The fit_predict
method assigns each student to a cluster.
5. Visualize the Clusters:
o We create a scatter plot to visualize the clusters based on Mathematics and
Science marks. The color of each point indicates the cluster to which the student
belongs.
6. Print the Cluster Assignment:
o We print the DataFrame with the cluster assignment to see which cluster each
student belongs to.
6. Compare and contrast supervised and Unsupervised learning with respect to their
data requirements, use cases, and limitations.

Answer 6: Supervised and unsupervised learning are two fundamental approaches in machine
learning, each with its own set of data requirements, use cases, and limitations. Here’s a
comparison and contrast between the two:

Supervised Learning

Data Requirements:

 Labeled Data: Requires a dataset where each example is paired with a corresponding
label or output.
 Example: In a spam detection task, emails are labeled as either "spam" or "not spam".

Use Cases:

1. Classification: Assigning inputs into predefined categories.

o Example: Image recognition (identifying objects in images).
2. Regression: Predicting continuous values.
o Example: House price prediction based on features like size, location, etc.

Strengths:

 Accuracy: Typically achieves high accuracy because the model learns from labeled
examples.
 Predictive Capability: Well-suited for predictive tasks where historical data can be
leveraged to make future predictions.
 Interpretability: Easier to interpret and validate since there is a clear mapping from
inputs to outputs.

Limitations:

 Data Dependence: Requires large amounts of labeled data, which can be expensive and
time-consuming to obtain.
 Overfitting: The model may overfit to the training data, especially if the dataset is small
or noisy.
 Scalability: Can struggle with scalability in terms of computational resources and time
when dealing with very large datasets.

Unsupervised Learning

Data Requirements:

 Unlabeled Data: Works with datasets that do not have labeled responses.
 Example: Customer purchasing patterns without any predefined categories.
 Use Cases:

1. Clustering: Grouping similar data points into clusters.

o Example: Customer segmentation based on buying behavior.
2. Dimensionality Reduction: Reducing the number of features while preserving important
information.
o Example: Principal Component Analysis (PCA) for visualizing high-dimensional
data.

Strengths:

 Flexibility: Can work with unlabeled data, which is more readily available and less
expensive to collect.
 Exploratory Analysis: Useful for discovering hidden patterns and relationships in the
data.
 Scalability: Often scales better with large datasets because it doesn't require labeled data.

Limitations:

 Interpretability: Results can be harder to interpret because there are no predefined

labels.
 Evaluation: It’s challenging to evaluate the performance of unsupervised learning
algorithms since there are no ground truth labels.
 Outcome Uncertainty: The lack of labeled data can lead to less precise outcomes, and
the clusters or patterns identified might not always make sense without domain
knowledge.

Comparative Summary:

 Data Requirements: Supervised learning requires labeled data, while unsupervised

learning works with unlabeled data.
 Use Cases: Supervised learning is ideal for tasks where we need to predict an outcome
(e.g., classification, regression), whereas unsupervised learning excels in exploratory
tasks (e.g., clustering, dimensionality reduction).
 Strengths and Limitations: Supervised learning provides high accuracy and clear
interpretability but needs labeled data and can overfit. Unsupervised learning is flexible,
scales well, and is suitable for discovering hidden patterns but can be harder to interpret
and evaluate.

Understanding these differences helps in selecting the appropriate learning approach

based on the specific problem and data characteristics.

7. Discuss the challenges of applying Machine Learning in a real-world project. What

factors should be considered when designing an ML-based solution?
 Answer 7: Applying Machine Learning (ML) in real-world projects comes with various
challenges and complexities. Here are some of the key challenges and important factors to
consider when designing an ML-based solution:

Challenges in Applying Machine Learning:

1. Data Quality and Quantity:

o Challenge: Acquiring high-quality, labeled data in sufficient quantity is often
difficult. Data may be incomplete, noisy, or biased.
o Solution: Invest time in data collection, cleaning, and preprocessing. Use
techniques like data augmentation or synthetic data generation if labeled data is
scarce.
2. Feature Engineering:
o Challenge: Identifying the right features that will allow the model to learn
effectively is crucial but can be complex and time-consuming.
o Solution: Use domain knowledge and exploratory data analysis (EDA) to identify
important features. Automated feature engineering tools can also help.
3. Model Selection and Tuning:
o Challenge: Choosing the right algorithm and tuning hyperparameters to optimize
model performance requires experimentation and expertise.
o Solution: Use cross-validation and grid search techniques to systematically
evaluate and compare models. Consider ensemble methods to combine strengths
of different models.
4. Scalability and Performance:
o Challenge: Ensuring that the ML solution can handle large-scale data and provide
results within a reasonable timeframe.
o Solution: Leverage distributed computing frameworks like Apache Spark or use
cloud-based solutions for scaling. Optimize code and algorithms for performance.
5. Interpretability and Explainability:
o Challenge: Complex models, like deep neural networks, can be difficult to
interpret, making it hard to explain decisions to stakeholders.
o Solution: Use techniques like SHAP (SHapley Additive exPlanations) or LIME
(Local Interpretable Model-agnostic Explanations) to provide insights into model
decisions.
6. Integration with Existing Systems:
o Challenge: Integrating the ML model with existing IT infrastructure and
workflows can be challenging.
o Solution: Ensure compatibility with existing systems and use APIs to facilitate
integration. Collaborate with IT teams to ensure smooth deployment.
7. Ethical and Legal Considerations:
o Challenge: ML models can unintentionally perpetuate biases and raise privacy
concerns.
o Solution: Conduct bias audits and fairness checks. Ensure compliance with data
protection regulations like GDPR. Implement ethical guidelines for AI use.

Factors to Consider When Designing an ML-Based Solution:

1. Clear Objectives:
o Define clear goals and success metrics for the ML project. Understand the
problem domain and what the solution aims to achieve.
2. Data Strategy:
o Develop a robust data strategy, including data collection, storage, processing, and
quality control. Ensure data privacy and security.
3. Model Selection:
o Choose appropriate models based on the problem type (classification, regression,
clustering, etc.) and the nature of the data. Consider model complexity,
interpretability, and scalability.
4. Evaluation Metrics:
o Define relevant evaluation metrics (accuracy, precision, recall, F1 score, etc.) to
measure model performance. Use cross-validation to ensure robustness.
5. Deployment Plan:
o Plan for deployment, including the infrastructure required for real-time or batch
predictions. Consider monitoring and maintenance strategies for the deployed
model.
6. Human-in-the-Loop:
o Incorporate human oversight, especially in critical applications. Use feedback
loops to continuously improve the model based on human input.
7. Ethical Considerations:
o Address ethical concerns by ensuring transparency, fairness, and accountability in
the ML model's development and deployment. Engage with stakeholders to
understand and mitigate potential risks.

Example:

Consider a project aimed at predicting customer churn for a telecom company.

 Data: Customer usage data, service history, demographic information.

 Objectives: Identify customers likely to churn and take preventive actions.
 Challenges: Data quality issues, feature selection, balancing false positives and false
negatives.
 Solution: Use supervised learning with algorithms like Random Forest or Gradient
Boosting. Implement SHAP for explainability. Integrate with CRM systems to trigger
retention campaigns based on predictions.

By carefully addressing these challenges and considering the outlined factors,

organizations can develop robust and effective ML solutions that deliver real-world
value.
8. Explain the concept of reinforcement learning. Write a Python program that
simulates a basic reinforcement learning scenario, such as a robot learning to reach
a goal.

Answer 8: Concept of Reinforcement Learning

Reinforcement Learning (RL) is a type of machine learning where an agent learns to

make decisions by taking actions in an environment to maximize cumulative rewards.
The agent interacts with the environment through a series of steps, receiving feedback in
the form of rewards or penalties, and learns to adjust its actions to achieve the best long-
term outcome.

Key Components of Reinforcement Learning:

1. Agent: The learner or decision-maker that takes actions.

2. Environment: The external system with which the agent interacts.

3. State: A representation of the current situation in the environment.

4. Action: Choices made by the agent that affect the environment.

5. Reward: Feedback received from the environment based on the agent's action.

6. Policy: The strategy that the agent follows to determine actions based on states.

7. Value Function: Estimates the expected cumulative reward for states or state-action
pairs.

Example: Simulating a Robot Learning to Reach a Goal

Let's write a simple Python program to simulate a reinforcement learning scenario where
a robot learns to reach a goal in a grid world.

In this example, we'll use Q-Learning, a popular RL algorithm that allows the agent to
learn the value of actions in different states to maximize its cumulative reward.

import numpy as np

import random

# Define the environment

GRID_SIZE = 5

GOAL_STATE = (4, 4)
START_STATE = (0, 0)

ACTIONS = ['UP', 'DOWN', 'LEFT', 'RIGHT']

ALPHA = 0.1 # Learning rate

GAMMA = 0.9 # Discount factor

EPSILON = 0.1 # Exploration rate

# Initialize Q-table

Q_table = np.zeros((GRID_SIZE, GRID_SIZE, len(ACTIONS)))

def get_next_state(state, action):

i, j = state

if action == 'UP' and i > 0:

return (i-1, j)

elif action == 'DOWN' and i < GRID_SIZE-1:

return (i+1, j)

elif action == 'LEFT' and j > 0:

return (i, j-1)

elif action == 'RIGHT' and j < GRID_SIZE-1:

return (i, j+1)

return state

def choose_action(state):

if random.uniform(0, 1) < EPSILON:

return random.choice(ACTIONS) # Exploration

else:
 i, j = state

return ACTIONS[np.argmax(Q_table[i, j])] # Exploitation

def get_reward(state):

return 10 if state == GOAL_STATE else -1

# Training the agent

for episode in range(1000):

state = START_STATE

while state != GOAL_STATE:

action = choose_action(state)

next_state = get_next_state(state, action)

reward = get_reward(next_state)

i, j = state

ni, nj = next_state

Q_table[i, j, ACTIONS.index(action)] = Q_table[i, j, ACTIONS.index(action)] +

ALPHA * (

reward + GAMMA * np.max(Q_table[ni, nj]) - Q_table[i, j,

ACTIONS.index(action)])

state = next_state

# Testing the learned policy

state = START_STATE

steps = 0

print("Testing the learned policy:")

while state != GOAL_STATE and steps < 50: # Limit steps to avoid infinite loops

action = choose_action(state)
 print(f"Step {steps}: State: {state}, Action: {action}")

state = get_next_state(state, action)

steps += 1

if state == GOAL_STATE:

print(f"Reached the goal in {steps} steps!")

else:

print("Failed to reach the goal.")

# Output the Q-table

print("\nQ-table:")

print(Q_table)

Explanation:

1. Environment: A 5x5 grid where the robot starts at (0, 0) and needs to reach the goal at
(4, 4).

2. ACTIONS: The possible actions the robot can take (UP, DOWN, LEFT, RIGHT).

3. Q-table: A table storing the Q-values for each state-action pair, representing the expected
cumulative reward.

4. get_next_state: A function to determine the next state based on the current state and
action.

5. choose_action: A function to choose the action based on an ε-greedy policy (balance

between exploration and exploitation).

6. get_reward: A function to provide a reward for reaching the goal or a penalty otherwise.

7. Training: The agent explores the environment, updates the Q-values, and learns the
optimal policy.

8. Testing: The agent uses the learned policy to navigate from the start to the goal and
evaluates its performance.

This basic reinforcement learning example demonstrates how an agent can learn to reach
a goal through trial and error, improving its strategy over time based on feedback from
the environment.