305 BA: MACHINE LEARNING & COGNITIVE INTELLIGENCE USING PYTHON 5860

Q.1. a) State how to define variable in python? b) Identify any two features of machine learning. c) List various
loops in python. d) List any two differences between lists and sets. e) What do you mean by operator overloading
in python? f) Define the term cognitive intelligence. g) Identify the steps of CRISP - DM Methodology. h) What
do you mean by data visualisation?
a) In Python, you can define a variable by simply assigning a value to a name. For example:

```python
variable_name = 42
```

b) Two features of machine learning are:

1. **Supervised Learning:** It involves training a model on a labeled dataset, where the algorithm
learns from the input-output pairs.

2. **Unsupervised Learning:** In this type of learning, the algorithm is given data without explicit
instructions on what to do with it. The system tries to learn the patterns and the structure from the
data.

c) Various loops in Python include:

1. **for loop:**
```python
for item in iterable:
# code to be executed
```

2. **while loop:**
```python
while condition:
 # code to be executed
```

d) Two differences between lists and sets in Python:

- Lists allow duplicate elements, while sets do not. Each element in a set must be unique.
- Lists are ordered, meaning the elements have a specific order, and you can access them using
indices. Sets, on the other hand, are unordered.

e) Operator overloading in Python refers to the ability to define multiple behaviors for a single
operator depending on the operands. It allows you to define how operators should behave for
objects of your own classes.

f) **Cognitive Intelligence:** This term refers to the capability of a computer program or system to
simulate human-like thought processes. It involves understanding, reasoning, learning, problem-
solving, and adapting to new situations.

g) Steps of CRISP-DM Methodology (Cross-Industry Standard Process for Data Mining):

1. **Business Understanding:** Define the business problem, the goals of the data mining project,
and the criteria for success.

2. **Data Understanding:** Collect and explore the data needed for the project, identify data
quality issues, and understand the structure of the data.

3. **Data Preparation:** Cleanse, preprocess, and format the data for analysis. This step also
involves feature engineering and transformation.

4. **Modeling:** Select and apply various modeling techniques, tune parameters, and validate the
models to find the best one for the given problem.

5. **Evaluation:** Evaluate the models' performance against the business objectives and criteria
defined in the first step.
6. **Deployment:** Deploy the model into the production environment and monitor its
performance.

h) **Data Visualization:** It is the representation of data in a graphical or pictorial format. The goal
is to provide insights into complex datasets by presenting them in a more understandable and
interpretable form, making it easier to identify patterns, trends, and outliers. Data visualization can
include charts, graphs, maps, and other visual elements to convey information effectively.

Q.2. a) Describe Numpy Arrays. Explain with example.

b) Distinguish between clustering and classification in machine learning.

c) Discuss the Reinforcement learning with example.

a) **Numpy Arrays:**
NumPy is a powerful Python library for numerical and mathematical operations. One of its key
features is the array object, which is a multidimensional array providing efficient storage and
manipulation of large datasets. Here's an example of how to create and work with NumPy arrays:

```python
import numpy as np

# Creating a 1-dimensional array

arr_1d = np.array([1, 2, 3, 4, 5])
print("1D Array:")
print(arr_1d)

# Creating a 2-dimensional array

arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("\n2D Array:")
print(arr_2d)
# Accessing elements
print("\nElement at row 1, column 2:", arr_2d[0, 1])

# Basic operations
print("\nSum along columns:", np.sum(arr_2d, axis=0))
```

NumPy arrays are essential for numerical operations in Python, providing a foundation for many
other libraries and tools in the data science and machine learning ecosystem.

b) **Clustering vs. Classification:**

- **Clustering:** Clustering is an unsupervised learning technique where the algorithm tries to

group similar data points based on some inherent patterns or similarities without any predefined
labels. The goal is to discover the inherent structure present in the data.

- **Classification:** Classification is a supervised learning technique where the algorithm learns

from labeled data to predict the labels of new, unseen data. The model is trained on a dataset with
input-output pairs, and the goal is to map input features to predefined output classes.

In summary, clustering involves finding natural groupings in the data without prior knowledge of the
groups, while classification involves learning from labeled examples to predict the class labels of
new instances.

c) **Reinforcement Learning with Example:**

Reinforcement Learning (RL) is a type of machine learning where an agent learns how to behave in
an environment by performing actions and receiving rewards. The goal is for the agent to learn the
optimal policy (sequence of actions) to maximize cumulative reward. Here's a simple example:

Imagine training an agent to play a game. The agent takes actions (e.g., moving left or right) in an
environment (the game), and after each action, it receives a reward or penalty based on its
performance. The agent's objective is to learn the best sequence of actions to maximize its
cumulative score.

```python
# Example of a basic reinforcement learning scenario
# (Note: This is a conceptual example, not actual code)

# Environment
game_environment = Game()

# Agent
class Agent:
def __init__(self):
self.q_values = {} # Q-values represent the expected cumulative reward for each action-state
pair

def choose_action(self, state):

# Exploration-exploitation trade-off
if np.random.rand() < exploration_rate:
return random_action()
else:
return self.get_best_action(state)

def update_q_values(self, state, action, reward, next_state):

# Update Q-values based on the reward and the next state
q_value = calculate_new_q_value(reward, next_state)
self.q_values[(state, action)] = q_value

# Training loop
agent = Agent()
for episode in range(num_episodes):
state = game_environment.reset()
total_reward = 0

for step in range(max_steps_per_episode):

action = agent.choose_action(state)
next_state, reward, done = game_environment.take_action(action)
agent.update_q_values(state, action, reward, next_state)

total_reward += reward
state = next_state

if done:
break

print("Episode {}: Total Reward: {}".format(episode, total_reward))

```

In this example, the agent learns the optimal actions to take in different states of the game by
updating its Q-values based on the received rewards. Over time, the agent refines its strategy to
maximize cumulative reward.

Q.3. a) Explain the decision tree algorithm in machine learning with example.

b) Explain the concept of simple and multiple regression.

a) **Decision Tree Algorithm in Machine Learning:**

A decision tree is a supervised machine learning algorithm used for both classification and
regression tasks. It works by recursively partitioning the data into subsets based on the most
significant attribute at each level of the tree. The process continues until a stopping criterion is met,
such as a specific depth or purity threshold.
Here's a simplified example of a decision tree for a binary classification problem (e.g., predicting
whether a passenger survives on the Titanic):

```plaintext
Decision Tree for Survival Prediction:
-----------------------------------------
- If gender is male:
- If age <= 10:
- Predict: Survived
- If age > 10:
- If class is 1st or 2nd:
- Predict: Survived
- If class is 3rd:
- Predict: Not Survived
- If gender is female:
- Predict: Survived
```

In this example, the decision tree makes decisions based on the features (gender, age, and class) to
predict whether a passenger survived or not. Each node represents a decision based on a feature,
and each branch represents the outcome of that decision. The leaves of the tree contain the final
predictions.

The decision tree algorithm recursively selects the best feature to split the data based on criteria like
Gini impurity or information gain, optimizing for the most significant reduction in uncertainty or
impurity.

b) **Simple and Multiple Regression:**

**Simple Regression:**
Simple linear regression is a statistical method to model the relationship between a single
independent variable (feature) and a dependent variable (target) by fitting a linear equation to the
observed data. The equation takes the form:

\[ Y = mX + b \]

where:
- \( Y \) is the dependent variable.
- \( X \) is the independent variable.
- \( m \) is the slope of the line.
- \( b \) is the y-intercept.

For example, consider predicting the price (\( Y \)) of a house based on its square footage (\( X \)).
The simple linear regression model would find the best-fitting line to represent this relationship.

**Multiple Regression:**
Multiple linear regression extends simple regression to model the relationship between two or more
independent variables and a dependent variable. The equation takes the form:

\[ Y = b_0 + b_1X_1 + b_2X_2 + \ldots + b_nX_n \]

where:
- \( Y \) is the dependent variable.
- \( X_1, X_2, \ldots, X_n \) are the independent variables.
- \( b_0 \) is the y-intercept.
- \( b_1, b_2, \ldots, b_n \) are the coefficients for the respective independent variables.

For example, predicting the price (\( Y \)) of a house based on square footage (\( X_1 \)), number of
bedrooms (\( X_2 \)), and distance to the city center (\( X_3 \)) would involve multiple linear
regression. The model estimates the coefficients (\( b_0, b_1, b_2, b_3 \)) that best fit the observed
data.

Q.4. a) Discuss how the clustering is useful in marketing domain?

b) Analyse K - Nearest Neighbour algorithm for machine learning.

a) **Clustering in the Marketing Domain:**

Clustering is highly useful in the marketing domain for various purposes. Here are some ways in
which clustering can be applied:

1. **Customer Segmentation:**
- Identify distinct groups of customers based on their purchasing behavior, demographics, or
preferences.
- Tailor marketing strategies for each segment to increase the effectiveness of targeted campaigns.
- For example, a retail business might discover segments like "frequent shoppers," "budget-
conscious buyers," or "occasional buyers."

2. **Product Recommendations:**
- Analyze customer purchase histories and preferences to recommend products or services based
on similar customer behavior.
- Improve cross-selling and upselling by understanding which products are commonly bought
together.
- For instance, an e-commerce platform might recommend products to users based on the
preferences of others in the same cluster.

3. **Market Basket Analysis:**

- Identify associations and patterns in customer purchases to optimize product placement and
promotion strategies.
- Understand which products are frequently purchased together and use this information for
strategic product bundling.
- Supermarkets, for example, can optimize shelf layouts based on the relationships between
products.

4. **Targeted Marketing Campaigns:**

- Customize marketing messages for specific customer segments to enhance engagement.
 - Clustering helps in identifying the right audience for a particular promotion, ensuring that
marketing efforts are more personalized and relevant.
- For example, a company might run different advertising campaigns for different clusters of
customers.

5. **Churn Analysis:**
- Predict and identify customers at risk of churning by analyzing their behavior and characteristics.
- Develop retention strategies tailored to different customer segments to reduce churn rates.
- Telecommunication companies, for instance, can identify clusters of customers with higher
likelihoods of churning.

b) **K-Nearest Neighbors (KNN) Algorithm:**

The K-Nearest Neighbors algorithm is a supervised machine learning algorithm used for classification
and regression tasks. Here's an overview of how it works:

- **Basic Idea:**
- Given a new data point, KNN classifies or predicts its label based on the majority class or average
of the K nearest data points in the feature space.
- The "nearest" data points are determined by a distance metric, often Euclidean distance.

- **Steps:**
1. **Choose K:** Select the number of neighbors, K.
2. **Calculate Distances:** Compute the distance between the new data point and all other data
points in the training set.
3. **Identify Neighbors:** Identify the K nearest neighbors based on the calculated distances.
4. **Majority Vote (Classification) or Average (Regression):**
- For classification, assign the class label that is most common among the K neighbors.
- For regression, predict the average of the target values of the K neighbors.

- **Parameters:**
 - The choice of K and the distance metric are critical parameters in KNN.

- **Example:**
- For a simple classification example, consider predicting whether a point belongs to class A or B on
a 2D plane. If K = 3, the algorithm would classify the point based on the majority class of its three
nearest neighbors.

```python
from sklearn.neighbors import KNeighborsClassifier

# Example usage of KNN for classification

X_train = [[1, 2], [2, 3], [3, 1]]
y_train = [0, 0, 1] # Class labels

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# Predicting the class of a new point

X_new = [[2.5, 2]]
prediction = knn.predict(X_new)
print("Predicted class:", prediction)
```

In this example, the KNN algorithm is trained on a small dataset, and then it predicts the class of a
new point based on the classes of its three nearest neighbours.

Q.5. a) Design a code in python to print the following pattern.

**

***

****

*****

b) "Machine learning will make companies more efficient and allow them to streamline business processes of an
organisation". Justify the statement.
a) **Python Code for the Pattern:**

Here's a simple Python code to print the given pattern:

```python
def print_pattern(rows):
for i in range(1, rows + 1):
for j in range(1, i + 1):
print("*", end=" ")
print()

for i in range(rows - 1, 0, -1):

for j in range(1, i + 1):
print("*", end=" ")
print()

# Set the number of rows for the pattern

num_rows = 5
print_pattern(num_rows)
```

This code defines a function `print_pattern` that takes the number of rows as an argument and
prints the pattern accordingly. The pattern consists of two parts: the increasing part and the
decreasing part.

b) **Justification for the Statement:**

"Machine learning will make companies more efficient and allow them to streamline business
processes of an organisation."
Justification:

1. **Automated Decision-Making:**
- Machine learning enables companies to automate decision-making processes by analyzing large
datasets and learning patterns.
- Automation reduces the time and effort required for routine decision-making tasks, making
processes more efficient.

2. **Predictive Analytics:**
- Machine learning models can predict future trends and outcomes based on historical data.
- Companies can use these predictions to anticipate demand, optimize inventory, and make
strategic decisions, leading to better efficiency.

3. **Personalization and Customer Engagement:**

- Machine learning algorithms analyze customer behavior to provide personalized
recommendations and experiences.
- This personalized approach enhances customer engagement, leading to increased satisfaction
and loyalty.

4. **Process Optimization:**
- ML algorithms can optimize complex business processes by identifying bottlenecks and
inefficiencies.
- Streamlining these processes improves overall efficiency and resource utilization.

5. **Cost Reduction:**
- Automation through machine learning can significantly reduce operational costs by replacing
manual and repetitive tasks.
- Companies can allocate resources more effectively and focus on high-value tasks.

6. **Fraud Detection and Security:**

 - Machine learning algorithms can detect anomalous patterns in data, enhancing fraud detection
capabilities.
- Improved security measures contribute to the overall efficiency of business operations.

7. **Supply Chain Management:**

- ML aids in optimizing supply chain processes by predicting demand, managing inventory levels,
and improving logistics.
- Companies can avoid overstocking or stockouts, leading to cost savings and increased efficiency.

8. **Data-Driven Decision-Making:**
- Machine learning facilitates data-driven decision-making by extracting insights from vast
datasets.
- Informed decisions based on data contribute to more efficient and effective business operations.

In summary, machine learning empowers companies to leverage data for smarter decision-making,
automate processes, and enhance various aspects of business operations, ultimately leading to
increased efficiency and competitiveness.
 305BA Machine Learning and Cognitive Intelligence using Python 5946

Q.1. a) Write a code in Python to display message “Hello World” b) Why there is need of machine
learning? c) List basic operators used in Python. d) State any 2 differences between Lists and Tuples. e)
What do you understand by function overloading in python? f) Define the term ‘Cognitive Intelligence’.
g) Idenfity the steps of KDD framework of machine Learning. h) Explain the term ‘Data Cleaning &
a)Preparation’
**Pythonwhile Codeworking
to Display "Hello World":**
with Data in Python. [

```python
print("Hello World")
```

This simple Python code uses the `print` function to display the message "Hello World" on
the console.

b) **Need for Machine Learning:**

Machine learning is needed for several reasons:

- **Complexity of Data:**
- In today's world, data is generated at an unprecedented rate, and it is often complex and
unstructured. Machine learning algorithms can extract meaningful patterns and insights from
large datasets.

- **Automation:**
- Machine learning enables automation of tasks that would be difficult or impractical to
program explicitly. This includes tasks like image recognition, natural language processing,
and decision-making.

- **Predictive Analysis:**
- Businesses benefit from machine learning for predictive analytics, allowing them to
forecast trends, make informed decisions, and gain a competitive advantage.
- **Personalization:**
- Machine learning is used to create personalized experiences for users, whether in
recommendations on e-commerce platforms, content recommendations on streaming
services, or targeted advertising.

- **Optimization:**
- ML algorithms optimize processes in various industries, such as supply chain management,
resource allocation, and logistics, leading to increased efficiency.

- **Fraud Detection:**
- Machine learning plays a crucial role in detecting fraudulent activities by identifying
patterns that may indicate fraudulent behavior in financial transactions, online activities, etc.

- **Healthcare and Medicine:**

- In healthcare, machine learning is used for disease prediction, diagnosis, personalized
treatment plans, and drug discovery.

- **Improved Decision-Making:**
- ML provides tools for analyzing data and making predictions, supporting better decision-
making across various domains.

c) **Basic Operators in Python:**

- **Arithmetic Operators:**
- `+` (addition)
- `-` (subtraction)
- `*` (multiplication)
- `/` (division)
- `%` (modulus)
- `**` (exponentiation)
- **Comparison Operators:**
- `==` (equal to)
- `!=` (not equal to)
- `<` (less than)
- `>` (greater than)
- `<=` (less than or equal to)
- `>=` (greater than or equal to)

- **Logical Operators:**
- `and` (logical AND)
- `or` (logical OR)
- `not` (logical NOT)

- **Assignment Operators:**
- `=` (assignment)
- `+=` (addition assignment)
- `-=` (subtraction assignment)
- `*=` (multiplication assignment)
- `/=` (division assignment)

- **Bitwise Operators:**
- `&` (bitwise AND)
- `|` (bitwise OR)
- `^` (bitwise XOR)
- `~` (bitwise NOT)
- `<<` (left shift)
- `>>` (right shift)
- **Membership Operators:**
- `in` (True if value is found in the sequence)
- `not in` (True if value is not found in the sequence)

- **Identity Operators:**
- `is` (True if both variables refer to the same object)
- `is not` (True if variables do not refer to the same object)

d) **Differences between Lists and Tuples:**

1. **Mutability:**
- Lists are mutable, meaning you can modify their elements (add, remove, or change) after
creation.
- Tuples are immutable; once created, you cannot change, add, or remove elements.

2. **Syntax:**
- Lists are defined using square brackets `[]`.
```python
my_list = [1, 2, 3]
```
- Tuples are defined using parentheses `()`.
```python
my_tuple = (1, 2, 3)
```

e) **Function Overloading in Python:**

Python does not support traditional function overloading like some other languages (e.g.,
C++). However, Python allows a single function to have different implementations based on
the number or types of its parameters. This is known as "polymorphism" and is achieved
through default values and variable-length argument lists.

For example:

```python
def add_numbers(a, b=0, c=0):
return a + b + c

result1 = add_numbers(1)
result2 = add_numbers(1, 2)
result3 = add_numbers(1, 2, 3)

print(result1, result2, result3)

```

In this example, the `add_numbers` function can take one, two, or three arguments, and it
returns the sum of the provided values. If not provided, the default values are used.

f) **Cognitive Intelligence:**

Cognitive intelligence refers to the ability of a system or entity to simulate and replicate
human-like thought processes, including perception, reasoning, learning, problem-solving,
and understanding natural language. It involves the use of advanced technologies like
artificial intelligence, machine learning, and deep learning to mimic human cognitive
functions.

g) **Steps of KDD Framework in Machine Learning:**

Knowledge Discovery in Databases (KDD) is a process that involves extracting useful patterns
and knowledge from large datasets. The steps of the KDD framework include:

1. **Selection:**
- Define the target dataset and select relevant data to be analyzed.

2. **Preprocessing:**
- Clean the data by handling missing values, outliers, and noise.

3. **Transformation:**
- Convert raw data into a suitable format for analysis, which may involve feature
engineering or scaling.

4. **Data Mining:**
- Apply machine learning algorithms to discover patterns, trends, or relationships in the
data.

5. **Interpretation/Evaluation:**
- Interpret the results of data mining and evaluate the discovered patterns for their
significance and reliability.

6. **Utilization:**
- Apply the knowledge and insights gained from the data to make informed decisions or
take appropriate actions.

h) **Data Visualization:**

Data visualization is the representation of data in graphical or visual formats, such as charts,
graphs, and maps, to facilitate the understanding of patterns, trends, and insights in the data.
It involves the use of visual elements to communicate information effectively and is an
essential part of the data analysis process. Data visualization helps in presenting complex
information in a more understandable and interpretable form, making it easier for decision-
makers to grasp and analyze the data.

Q.2. a) How to read and write files with open statement? Explain with example.

b) Explain anyone Supervised Learning algorithm.

c) Describe SEMMA process model of machine learning.

a) **Reading and Writing Files with the `open` Statement:**

The `open` statement in Python is used to open and manipulate files. It has the following
syntax:

```python
with open('filename.txt', 'mode') as file:
# Perform operations on the file
```

Here, 'filename.txt' is the name of the file you want to open, and 'mode' is the mode in which
you want to open the file (`'r'` for reading, `'w'` for writing, `'a'` for appending, etc.).

**Reading from a File:**

```python
# Example of reading from a file
with open('example.txt', 'r') as file:
content = file.read()
print(content)
```
In this example, the content of the file 'example.txt' is read and printed.

**Writing to a File:**

```python
# Example of writing to a file
with open('output.txt', 'w') as file:
file.write('Hello, this is a sample text.\n')
file.write('Writing to a file is easy with Python.')
```

In this example, two lines of text are written to the file 'output.txt'.

b) **Supervised Learning Algorithm: Linear Regression**

**Linear Regression:**

Linear Regression is a supervised learning algorithm used for predicting the value of a
continuous variable based on one or more predictor features. It assumes a linear relationship
between the input features and the output variable.

**Example:**

Let's say we want to predict the price of houses based on their size. The linear regression
model would try to find the best-fitting line (linear equation) that minimizes the difference
between the predicted prices and the actual prices in the training data.

```python
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Example data
sizes = np.array([1400, 1600, 1700, 1875, 1100, 1550, 2350, 2450, 1425, 1700])
prices = np.array([245000, 312000, 279000, 308000, 199000, 219000, 405000, 324000,
319000, 255000])

# Reshape the data to fit the model

sizes = sizes.reshape(-1, 1)

# Create and fit the model

model = LinearRegression()
model.fit(sizes, prices)

# Make predictions for new data

new_sizes = np.array([2000, 1500]).reshape(-1, 1)
predictions = model.predict(new_sizes)

# Plot the data and the regression line

plt.scatter(sizes, prices, color='blue')
plt.plot(sizes, model.predict(sizes), color='red', linewidth=2)
plt.scatter(new_sizes, predictions, color='green', marker='x')
plt.xlabel('House Size (sq ft)')
plt.ylabel('House Price ($)')
plt.title('Linear Regression Example')
plt.show()
```
In this example, the linear regression model is trained on the sizes and prices of houses. It
then predicts the prices for new house sizes. The red line represents the best-fitting line, and
the green 'x' markers represent the predicted prices for new sizes.

c) **SEMMA Process Model of Machine Learning:**

SEMMA stands for Sample, Explore, Modify, Model, and Assess. It is a process model used in
data mining and machine learning for developing predictive models. Here's a brief overview:

1. **Sample:**
- Obtain a representative sample of the data to analyze. This involves selecting a subset of
data from the entire dataset.

2. **Explore:**
- Explore and visualize the data to understand its characteristics, identify patterns, and gain
insights. This step involves descriptive statistics, data visualization, and data profiling.

3. **Modify:**
- Preprocess the data by cleaning, transforming, and handling missing values. This step also
involves feature engineering, where new features are created or existing ones are modified
to improve model performance.

4. **Model:**
- Build and train predictive models using the prepared dataset. This step includes selecting
appropriate algorithms, training the models, and tuning parameters to optimize
performance.

5. **Assess:**
 - Evaluate the performance of the models using metrics such as accuracy, precision, recall,
or mean squared error. Assess the models against the business objectives to ensure they
meet the desired criteria.

The SEMMA process is iterative, and analysts may revisit earlier stages based on insights
gained during the later stages. It provides a structured framework for guiding the data mining
and machine learning process from data exploration to model assessment.

Q.3. a) Explain Supervised Learning technique using K-Nearest Neighbour method.

b) State and explain applications of supervised learning in any one domain which you know.

a) **Supervised Learning using K-Nearest Neighbors (KNN):**

**Supervised Learning:**
Supervised learning is a type of machine learning where the algorithm is trained on a labeled
dataset, which means the dataset includes both input features and corresponding target
labels. The goal is for the algorithm to learn a mapping from inputs to outputs, allowing it to
make predictions on new, unseen data.

**K-Nearest Neighbors (KNN):**

K-Nearest Neighbors is a supervised learning algorithm used for classification and regression
tasks. In the context of classification, given a new data point, the algorithm identifies the K
training data points closest to it in the feature space. The majority class among these K
neighbors is assigned to the new data point.

**Example of KNN for Classification:**

Let's consider a simple example where we want to classify whether a fruit is an apple or a
banana based on two features: sweetness and color. We have a labeled dataset with the
sweetness, color, and corresponding labels.

```python
from sklearn.neighbors import KNeighborsClassifier
# Sample dataset
X_train = [[8, 'red'], [6, 'yellow'], [7, 'red'], [4, 'yellow']]
y_train = ['apple', 'banana', 'apple', 'banana']

# Create a KNN classifier

knn_classifier = KNeighborsClassifier(n_neighbors=3)
knn_classifier.fit(X_train, y_train)

# Predict the class of a new fruit

new_fruit = [[7, 'red']]
predicted_class = knn_classifier.predict(new_fruit)

print("Predicted class:", predicted_class)

```

In this example, the KNN algorithm is trained on a dataset with labeled instances of fruits.
When given a new fruit with sweetness 7 and red color, the algorithm predicts that it is an
apple.

b) **Applications of Supervised Learning in Healthcare:**

**Application: Disease Diagnosis**

**Explanation:**
Supervised learning is extensively used in healthcare for disease diagnosis. Medical
professionals can collect datasets with features such as patient symptoms, test results, and
demographic information, along with corresponding labels indicating the presence or
absence of a particular disease.
**Example:**
Consider the application of supervised learning in diagnosing diabetes. A dataset may include
features like blood sugar levels, age, BMI, and family medical history, with labels indicating
whether the patient has diabetes or not. A supervised learning algorithm, such as a support
vector machine (SVM) or a decision tree, can be trained on this data to predict diabetes in
new patients.

**Benefits:**
1. **Early Detection:** Supervised learning models can assist in early detection of diseases,
enabling timely intervention and treatment.
2. **Personalized Medicine:** By analyzing patient-specific data, models can recommend
personalized treatment plans based on the individual's characteristics.
3. **Resource Optimization:** Efficient allocation of medical resources, such as prioritizing
screenings for individuals at higher risk, can be achieved using predictive models.

In healthcare, the application of supervised learning contributes to more accurate and timely
diagnoses, personalized patient care, and overall improvements in the efficiency of
healthcare processes.

Q.4. a) Elaborate the applications of unsupervised learning in marketing domain.

b) Distinguish between decision trees & linear regression technique with suitable example.

a) **Applications of Unsupervised Learning in Marketing:**

Unsupervised learning in marketing is valuable for discovering patterns, segmenting

customer groups, and gaining insights without labeled data. Here are some applications:

1. **Customer Segmentation:**
- **Objective:** Divide customers into meaningful segments based on their behavior,
preferences, or characteristics.
- **Example:** Clustering algorithms can group customers who exhibit similar purchasing
patterns. Marketers can then tailor specific strategies for each segment, improving the
effectiveness of targeted campaigns.
2. **Market Basket Analysis:**
- **Objective:** Identify associations and relationships between products frequently
purchased together.
- **Example:** Association rule mining algorithms can reveal that customers who buy
diapers are likely to purchase baby wipes. Retailers can use this information for strategic
product placement and bundling.

3. **Anomaly Detection:**
- **Objective:** Detect unusual or anomalous patterns in customer behavior that may
indicate fraud or other issues.
- **Example:** Unsupervised algorithms can flag unusual transactions or activities, helping
prevent fraudulent activities and enhancing security in e-commerce platforms.

4. **Content Recommendation:**
- **Objective:** Recommend products, services, or content based on users' preferences
and behavior.
- **Example:** Collaborative filtering algorithms can suggest movies, products, or articles
based on the preferences of users with similar behavior, leading to a more personalized user
experience.

5. **Social Media Analysis:**

- **Objective:** Analyze user-generated content to understand sentiment and identify
trends.
- **Example:** Clustering algorithms can group social media posts based on similar themes
or sentiments. Marketers can use this information to gauge public opinion and tailor their
messaging accordingly.

6. **Attribution Modeling:**
- **Objective:** Understand the contribution of each marketing channel to conversions.
 - **Example:** Unsupervised learning techniques can help identify the most influential
touchpoints in the customer journey, allowing marketers to allocate resources effectively and
optimize their marketing mix.

Unsupervised learning techniques empower marketers to uncover hidden patterns and

insights in their data, leading to more informed decision-making and targeted strategies.

b) **Distinguishing Decision Trees and Linear Regression:**

**Decision Trees:**
- Decision trees are a versatile supervised learning algorithm used for both classification and
regression tasks.
- They make decisions by recursively splitting the dataset based on the most significant
attribute at each node, aiming to create homogeneous subsets.
- The final result is a tree structure where each leaf node represents a class (for classification)
or a predicted value (for regression).

**Linear Regression:**
- Linear regression is a supervised learning algorithm used for predicting a continuous target
variable based on one or more independent features.
- It assumes a linear relationship between the input features and the output variable, fitting a
line to the data that minimizes the sum of squared errors.
- The model equation takes the form \(Y = mX + b\), where \(Y\) is the output, \(X\) is the
input, \(m\) is the slope, and \(b\) is the y-intercept.

**Differences:**
1. **Output Type:**
- Decision trees can be used for both classification and regression tasks.
- Linear regression is specifically designed for regression tasks, predicting continuous
numeric values.
2. **Model Representation:**
- Decision trees are represented as tree structures with nodes and branches.
- Linear regression is represented by a linear equation, typically a line in two dimensions or
a hyperplane in higher dimensions.

**Example:**
Consider predicting the price of a house based on its size:
- Decision Tree: The tree would make decisions at each node based on features like size,
location, and number of bedrooms, ultimately leading to a predicted price at the leaf node.
- Linear Regression: The linear regression model would find the best-fitting line that
minimizes the difference between the predicted and actual prices based on the size of the
house.

In summary, decision trees are versatile and suitable for both classification and regression,
while linear regression is specifically designed for regression tasks, predicting continuous
values based on a linear relationship between features and the target variable.

Q.5. a) Write a Python code for calculating factorial of a given number.

b) How machine learning techniques will be useful for fraud analysis for credit card. Explain.

a) **Python Code for Calculating Factorial:**

Here's a simple Python code to calculate the factorial of a given number using a recursive
function:

```python
def factorial(n):
if n == 0 or n == 1:
return 1
else:
 return n * factorial(n - 1)

# Example: Calculate factorial of 5

number = 5
result = factorial(number)
print(f"The factorial of {number} is: {result}")
```

In this code, the `factorial` function is defined recursively. It returns 1 for the base cases
(when \(n\) is 0 or 1) and calculates the factorial for other values.

b) **Machine Learning for Fraud Analysis in Credit Cards:**

Machine learning techniques are highly beneficial for fraud analysis in credit cards due to
their ability to detect patterns and anomalies in large datasets. Here's how they can be
useful:

1. **Anomaly Detection:**
- **Technique:** Unsupervised learning algorithms, such as clustering or isolation forests,
can detect anomalies in transaction patterns.
- **Use:** Identify unusual patterns that may indicate fraudulent activities, such as large
transactions, transactions from unfamiliar locations, or unusual spending behavior.

2. **Predictive Modeling:**
- **Technique:** Supervised learning algorithms, like decision trees or support vector
machines, can be trained on labeled datasets to predict the likelihood of a transaction being
fraudulent.
- **Use:** Predict and prioritize transactions with a higher likelihood of fraud, allowing for
proactive measures and timely intervention.
3. **Behavior Analysis:**
- **Technique:** Machine learning models can analyze the historical spending and
transaction patterns of users to establish a baseline of normal behavior.
- **Use:** Identify deviations from the established patterns, triggering alerts for
transactions that significantly differ from the user's typical behavior.

4. **Real-time Monitoring:**
- **Technique:** Stream processing and real-time analytics using machine learning models
enable immediate detection of suspicious activities.
- **Use:** Quickly identify and block potentially fraudulent transactions as they occur,
minimizing the impact on both cardholders and financial institutions.

5. **Feature Engineering:**
- **Technique:** Extract relevant features from transaction data, such as time of day,
transaction amount, location, and frequency.
- **Use:** Provide valuable information for machine learning models to identify patterns
associated with legitimate and fraudulent transactions.

6. **Ensemble Methods:**
- **Technique:** Combine multiple models (ensemble methods) to enhance the overall
fraud detection accuracy.
- **Use:** Improve the robustness of the fraud detection system by leveraging the
strengths of different algorithms.

Machine learning techniques enable credit card companies to adapt and evolve their fraud
detection strategies continuously. By learning from new patterns and emerging fraud tactics,
these models can enhance their accuracy over time, providing a more proactive and effective
defense against fraudulent activities.