Q1)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
# Replace ’fish_data.csv’ with the actual file path
# Ensure that the dataset contains columns including ’Weight’ and relevant features like ’Length’, ’Height’,
etc.
data = pd.read_csv(’fish_data.csv’)

# Separate features and target variable

X = data.drop(columns=[’Weight’]) # Input features
y = data[’Weight’] # Target variable

# Define train-test split ratios

split_ratios = [(0.8, 0.2), (0.7, 0.3), (0.6, 0.4)]

# Store results
results = []

# Train and evaluate the model for each split ratio

for train_ratio, test_ratio in split_ratios:
# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_ratio, random_state=42)

# Initialize and train the model

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

# Make predictions
y_pred = model.predict(X_test)

# Evaluate performance
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Store the results

results.append({
’Train Ratio’: train_ratio,
’Test Ratio’: test_ratio,
’MSE’: mse,
’R^2’: r2
})

# Display results
results_df = pd.DataFrame(results)
print(results_df)

# Compare and explain results

def explain_results(results):
print("\nModel Performance Explanation:")
for result in results:
train_ratio = result[’Train Ratio’]
 test_ratio = result[’Test Ratio’]
mse = result[’MSE’]
r2 = result[’R^2’]
print(f"Train-Test Split ({train_ratio*100}% - {test_ratio*100}%):")
print(f" Mean Squared Error (MSE): {mse:.2f}")
print(f" R-squared (R^2): {r2:.2f}\n")

explain_results(results)

Q2)
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
# Replace ’fish_data.csv’ with the actual file path
# Ensure that the dataset contains columns including ’Weight’ and relevant features like ’Length’, ’Height’,
etc.
data = pd.read_csv(’fish_data.csv’)

# Separate features and target variable

X = data.drop(columns=[’Weight’]) # Input features
y = data[’Weight’] # Target variable

# Define train-test split ratios

split_ratios = [(0.8, 0.2), (0.7, 0.3), (0.6, 0.4)]

# Store results
results = []

# Train and evaluate the models for each split ratio

for train_ratio, test_ratio in split_ratios:
# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_ratio, random_state=42)

# Simple Linear Regression

linear_model = LinearRegression()
linear_model.fit(X_train, y_train)
y_pred_linear = linear_model.predict(X_test)
mse_linear = mean_squared_error(y_test, y_pred_linear)
r2_linear = r2_score(y_test, y_pred_linear)

# Polynomial Regression (degree 2)

poly_pipeline = Pipeline([
(’poly_features’, PolynomialFeatures(degree=2)),
(’linear_model’, LinearRegression())
])
poly_pipeline.fit(X_train, y_train)
y_pred_poly = poly_pipeline.predict(X_test)
mse_poly = mean_squared_error(y_test, y_pred_poly)
r2_poly = r2_score(y_test, y_pred_poly)
 # Store the results
results.append({
’Train Ratio’: train_ratio,
’Test Ratio’: test_ratio,
’Linear MSE’: mse_linear,
’Linear R^2’: r2_linear,
’Poly MSE’: mse_poly,
’Poly R^2’: r2_poly
})

# Display results
results_df = pd.DataFrame(results)
print(results_df)

# Compare and explain results

def explain_results(results):
print("\nModel Performance Comparison:")
for result in results:
train_ratio = result[’Train Ratio’]
test_ratio = result[’Test Ratio’]
mse_linear = result[’Linear MSE’]
r2_linear = result[’Linear R^2’]
mse_poly = result[’Poly MSE’]
r2_poly = result[’Poly R^2’]
print(f"Train-Test Split ({train_ratio*100}% - {test_ratio*100}%):")
print(f" Linear Regression - MSE: {mse_linear:.2f}, R^2: {r2_linear:.2f}")
print(f" Polynomial Regression - MSE: {mse_poly:.2f}, R^2: {r2_poly:.2f}\n")

explain_results(results)

Q3)
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Load dataset
# Replace ’fish_data.csv’ with the actual file path
# Ensure that the dataset contains columns including ’Species’, ’Length1’, ’Length2’, ’Length3’, ’Height’,
and ’Width’
data = pd.read_csv(’fish_data.csv’)

# Encode the Species column into numerical values

label_encoder = LabelEncoder()
data[’Species’] = label_encoder.fit_transform(data[’Species’])

# Separate features and target variable

X = data[[’Length1’, ’Length2’, ’Length3’, ’Height’, ’Width’]] # Input features
y = data[’Species’] # Target variable

# Split the dataset into training and testing sets

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

# Define SVM kernels to evaluate

kernels = [’linear’, ’poly’, ’rbf’, ’sigmoid’]
results = []

# Train and evaluate the SVM model for each kernel

for kernel in kernels:
# Initialize and train the model
svm_model = SVC(kernel=kernel, random_state=42)
svm_model.fit(X_train, y_train)

# Make predictions
y_pred = svm_model.predict(X_test)

# Evaluate performance
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)

# Store the results

results.append({
’Kernel’: kernel,
’Accuracy’: accuracy,
’Confusion Matrix’: conf_matrix
})

# Print confusion matrix for the current kernel

print(f"\nKernel: {kernel}")
print(f"Accuracy: {accuracy:.2f}")
print("Confusion Matrix:")
print(conf_matrix)

# Plot confusion matrix

sns.heatmap(conf_matrix, annot=True, fmt=’d’, cmap=’Blues’, xticklabels=label_encoder.classes_,
yticklabels=label_encoder.classes_)
plt.title(f"Confusion Matrix - Kernel: {kernel}")
plt.xlabel(’Predicted’)
plt.ylabel(’Actual’)
plt.show()

# Identify the best-performing kernel

best_result = max(results, key=lambda x: x[’Accuracy’])
print(f"\nBest Kernel: {best_result[’Kernel’]}")
print(f"Accuracy: {best_result[’Accuracy’]:.2f}")

# Explanation of findings
def explain_findings(best_result):
print("\nExplanation of Findings:")
print(f"The best-performing kernel is ’{best_result[’Kernel’]}’ with an accuracy of
{best_result[’Accuracy’]:.2f}. ")
print("This suggests that the ’{best_result[’Kernel’]}’ kernel is most effective at capturing the relationship
between the features and the target variable.")

explain_findings(best_result)
Q4)
import numpy as np
import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Load the Wine dataset

data = load_wine()
X = data.data
y = data.target

# Split the dataset into training and testing sets

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

# Define scaling techniques

scalers = {
’StandardScaler’: StandardScaler(),
’MinMaxScaler’: MinMaxScaler(),
’RobustScaler’: RobustScaler()
}

# Define SVM kernels

kernels = [’linear’, ’poly’, ’rbf’, ’sigmoid’]

# Store results
results = []

for scaler_name, scaler in scalers.items():

# Scale the data
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

for kernel in kernels:

# Train SVM model
svm = SVC(kernel=kernel, random_state=42)
svm.fit(X_train_scaled, y_train)

# Make predictions
y_pred = svm.predict(X_test_scaled)

# Evaluate performance
accuracy = accuracy_score(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)

results.append({
’Scaler’: scaler_name,
’Kernel’: kernel,
’Accuracy’: accuracy,
’Confusion Matrix’: cm
 })

# Display results
best_result = max(results, key=lambda x: x[’Accuracy’])

print("Best Result:")
print(f"Scaler: {best_result[’Scaler’]}")
print(f"Kernel: {best_result[’Kernel’]}")
print(f"Accuracy: {best_result[’Accuracy’]:.4f}")
print("Confusion Matrix:")
print(best_result[’Confusion Matrix’])

# Visualize confusion matrix of the best result

sns.heatmap(best_result[’Confusion Matrix’], annot=True, fmt=’d’, cmap=’Blues’,
xticklabels=data.target_names, yticklabels=data.target_names)
plt.xlabel(’Predicted’)
plt.ylabel(’Actual’)
plt.title(f"Best Combination: {best_result[’Scaler’]} + {best_result[’Kernel’]}\nAccuracy:
{best_result[’Accuracy’]:.4f}")
plt.show()

# Summary of findings
print("\nSummary of Findings:")
print(f"The best performance was achieved with the {best_result[’Scaler’]} scaling method and the
{best_result[’Kernel’]} kernel. This scaling method is likely best suited for the dataset because it effectively
handles feature distributions and scales them appropriately for the SVM kernel.")

Q5)
import numpy as np
import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix,
classification_report
import seaborn as sns
import matplotlib.pyplot as plt

# Load the Wine dataset

data = load_wine()
X = data.data
y = data.target

# Split the dataset into training and testing sets

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

# Scale the features

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train logistic regression using One-vs-Rest (OvR) strategy

ovr_model = OneVsRestClassifier(LogisticRegression(random_state=42, max_iter=10000))
ovr_model.fit(X_train_scaled, y_train)
ovr_preds = ovr_model.predict(X_test_scaled)

# Train logistic regression using One-vs-One (OvO) strategy

ovo_model = OneVsOneClassifier(LogisticRegression(random_state=42, max_iter=10000))
ovo_model.fit(X_train_scaled, y_train)
ovo_preds = ovo_model.predict(X_test_scaled)

# Evaluate models
metrics = {}

# One-vs-Rest (OvR) metrics

metrics[’OvR’] = {
’Accuracy’: accuracy_score(y_test, ovr_preds),
’Precision’: precision_score(y_test, ovr_preds, average=’weighted’),
’Recall’: recall_score(y_test, ovr_preds, average=’weighted’),
’Confusion Matrix’: confusion_matrix(y_test, ovr_preds)
}

# One-vs-One (OvO) metrics

metrics[’OvO’] = {
’Accuracy’: accuracy_score(y_test, ovo_preds),
’Precision’: precision_score(y_test, ovo_preds, average=’weighted’),
’Recall’: recall_score(y_test, ovo_preds, average=’weighted’),
’Confusion Matrix’: confusion_matrix(y_test, ovo_preds)
}

# Display results
for strategy, result in metrics.items():
print(f"\n{strategy} Strategy:")
print(f"Accuracy: {result[’Accuracy’]:.4f}")
print(f"Precision: {result[’Precision’]:.4f}")
print(f"Recall: {result[’Recall’]:.4f}")
print("Confusion Matrix:")
print(result[’Confusion Matrix’])

sns.heatmap(result[’Confusion Matrix’], annot=True, fmt=’d’, cmap=’Blues’,

xticklabels=data.target_names, yticklabels=data.target_names)
plt.xlabel(’Predicted’)
plt.ylabel(’Actual’)
plt.title(f"{strategy} Strategy Confusion Matrix")
plt.show()

# Summary of findings
if metrics[’OvR’][’Accuracy’] > metrics[’OvO’][’Accuracy’]:
better_strategy = ’One-vs-Rest (OvR)’
else:
better_strategy = ’One-vs-One (OvO)’

print("\nSummary of Findings:")
print(f"The better-performing strategy is {better_strategy}. OvR is generally simpler and may perform well
on datasets with a large number of classes, whereas OvO could be more computationally intensive but
might better capture pairwise class distinctions.")
Q6)
import numpy as np
import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Load the Wine dataset

data = load_wine()
X = data.data
y = data.target

# Split the dataset into training and testing sets

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

# Standardize the features

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Initialize results storage

results = []

# Try different numbers of principal components

for n_components in range(1, X.shape[1] + 1):
# Apply PCA
pca = PCA(n_components=n_components)
X_train_pca = pca.fit_transform(X_train_scaled)
X_test_pca = pca.transform(X_test_scaled)

# Train Logistic Regression model

model = LogisticRegression(random_state=42, max_iter=10000)
model.fit(X_train_pca, y_train)

# Evaluate the model

y_pred = model.predict(X_test_pca)
accuracy = accuracy_score(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)

# Store results
results.append({
’n_components’: n_components,
’Accuracy’: accuracy,
’Confusion Matrix’: cm
})

# Find the best result

best_result = max(results, key=lambda x: x[’Accuracy’])
# Print results
print("Optimal Number of Principal Components:")
print(f"Number of Components: {best_result[’n_components’]}")
print(f"Accuracy: {best_result[’Accuracy’]:.4f}")
print("Confusion Matrix:")
print(best_result[’Confusion Matrix’])

# Plot accuracy vs. number of principal components

n_components = [result[’n_components’] for result in results]
accuracies = [result[’Accuracy’] for result in results]
plt.plot(n_components, accuracies, marker=’o’)
plt.title(’Accuracy vs. Number of Principal Components’)
plt.xlabel(’Number of Principal Components’)
plt.ylabel(’Accuracy’)
plt.grid()
plt.show()

# Visualize the confusion matrix for the best result

sns.heatmap(best_result[’Confusion Matrix’], annot=True, fmt=’d’, cmap=’Blues’,
xticklabels=data.target_names, yticklabels=data.target_names)
plt.xlabel(’Predicted’)
plt.ylabel(’Actual’)
plt.title(f"Confusion Matrix (n_components={best_result[’n_components’]})")
plt.show()

# Summary of findings
print("\nSummary of Findings:")
print(f"The optimal number of principal components is {best_result[’n_components’]}, achieving an
accuracy of {best_result[’Accuracy’]:.4f}. PCA helps reduce the dimensionality of the dataset while
retaining essential information, improving model performance or interpretability.")

Q7)
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Load dataset
# Replace ’your_dataset.csv’ with the actual file path
data = pd.read_csv(’your_dataset.csv’)

# Inspect the dataset

print("Dataset Head:")
print(data.head())
print("\nDataset Info:")
print(data.info())
print("\nSummary Statistics:")
print(data.describe())

# Visualize the distribution of key features

features_to_plot = [’Relative Compactness’, ’Surface Area’, ’Wall Area’, ’Roof Area’, ’Heating Load’,
’Cooling Load’]
for feature in features_to_plot:
plt.figure(figsize=(6, 4))
sns.histplot(data[feature], kde=True, bins=20)
plt.title(f’Distribution of {feature}’)
plt.show()

# Pair plot for relationships between features

sns.pairplot(data[features_to_plot], diag_kind=’kde’)
plt.show()

# Check for missing values

print("\nMissing Values:")
print(data.isnull().sum())

# Handle missing values (if any)

data = data.dropna()

# Normalize the features for clustering

scaler = StandardScaler()
normalized_data = scaler.fit_transform(data[features_to_plot])

# Perform K-Means clustering with 3 and 4 clusters

clusters = [3, 4]
kmeans_results = {}

for k in clusters:
kmeans = KMeans(n_clusters=k, random_state=42)
labels = kmeans.fit_predict(normalized_data)
kmeans_results[k] = labels
data[f’Cluster_{k}’] = labels

# Visualize clusters using PCA (reduce to 2D for visualization)

pca = PCA(n_components=2)
reduced_data = pca.fit_transform(normalized_data)
plt.figure(figsize=(8, 6))
sns.scatterplot(
x=reduced_data[:, 0], y=reduced_data[:, 1], hue=labels, palette=’Set1’, s=50
)
plt.title(f’K-Means Clustering with {k} Clusters (PCA Reduced)’)
plt.xlabel(’PCA Component 1’)
plt.ylabel(’PCA Component 2’)
plt.legend(title=’Cluster’)
plt.show()

# Interpretation of clusters
for k in clusters:
print(f"\nCluster Centers for K={k}:")
centers = pd.DataFrame(
scaler.inverse_transform(kmeans.cluster_centers_),
columns=features_to_plot
)
print(centers)
# Save the results to a CSV file
data.to_csv(’clustered_data.csv’, index=False)

print("\nClustering completed. Results saved to ’clustered_data.csv’.")

Q8)
# Import necessary libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import DBSCAN
from sklearn.decomposition import PCA

# Load the dataset

data = pd.read_csv(’building_energy_efficiency.csv’)

# Display basic information about the dataset

print("Dataset Info:")
print(data.info())

# Display the first few rows of the dataset

print("\nFirst 5 Rows:")
print(data.head())

# Display summary statistics

print("\nSummary Statistics:")
print(data.describe())

# Check for missing values

print("\nMissing Values:")
print(data.isnull().sum())

# Data Visualization
# Histogram for each numerical feature
data.hist(figsize=(12, 8))
plt.tight_layout()
plt.show()

# Scatter plot matrix

sns.pairplot(data)
plt.show()

# Box plots for target variables

plt.figure(figsize=(10, 6))
sns.boxplot(data=data[[’Relative Compactness’, ’Surface Area’, ’Wall Area’, ’Roof Area’, ’Heating Load’,
’Cooling Load’]])
plt.title(’Box plots of features’)
plt.show()

# Normalize the features

scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)

# Apply DBSCAN clustering

dbscan = DBSCAN(eps=0.3, min_samples=5)
clusters = dbscan.fit_predict(scaled_data)

# Add cluster labels to the dataset

data[’Cluster’] = clusters

# Visualize the clusters using PCA for dimensionality reduction

pca = PCA(n_components=2)
pca_data = pca.fit_transform(scaled_data)

plt.figure(figsize=(8, 6))
plt.scatter(pca_data[:, 0], pca_data[:, 1], c=clusters, cmap=’viridis’, s=50, alpha=0.6)
plt.title(’DBSCAN Clustering Results’)
plt.xlabel(’PCA Component 1’)
plt.ylabel(’PCA Component 2’)
plt.colorbar(label=’Cluster Label’)
plt.show()

# Interpretation of results
print("\nDBSCAN Clustering Results:")
unique_clusters = np.unique(clusters)
print(f"Number of clusters: {len(unique_clusters) - (1 if -1 in clusters else 0)}")
print(f"Noise points: {np.sum(clusters == -1)}")

# Provide interpretation based on clusters

for cluster in unique_clusters:
if cluster != -1:
print(f"Cluster {cluster}:")
cluster_data = data[data[’Cluster’] == cluster]
print(cluster_data.describe())

Q9)
# Import necessary libraries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Load the dataset

df = pd.read_csv(’path_to_your_dataset.csv’)

# Handle missing values (fill with median for numerical features and mode for categorical features)
imputer_num = SimpleImputer(strategy=’median’)
imputer_cat = SimpleImputer(strategy=’most_frequent’)

df[’age’] = imputer_num.fit_transform(df[[’age’]])
df[’education’] = imputer_cat.fit_transform(df[[’education’]])
df[’occupation’] = imputer_cat.fit_transform(df[[’occupation’]])

# Encode categorical features

label_enc = LabelEncoder()
df[’education’] = label_enc.fit_transform(df[’education’])
df[’occupation’] = label_enc.fit_transform(df[’occupation’])

# Separate features and target variable

X = df.drop(’income’, axis=1)
y = df[’income’]

# Normalize the numeric features

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X.select_dtypes(include=[’int64’, ’float64’]))

# Split the dataset into training and testing sets

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

# Train Logistic Regression model

log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
y_pred_log = log_reg.predict(X_test)

# Train Decision Tree model

decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, y_train)
y_pred_tree = decision_tree.predict(X_test)

# Evaluate models
def evaluate_model(y_true, y_pred):
accuracy = accuracy_score(y_true, y_pred)
precision = precision_score(y_true, y_pred, pos_label=’>50K’)
recall = recall_score(y_true, y_pred, pos_label=’>50K’)
f1 = f1_score(y_true, y_pred, pos_label=’>50K’)
return accuracy, precision, recall, f1

log_reg_metrics = evaluate_model(y_test, y_pred_log)

tree_metrics = evaluate_model(y_test, y_pred_tree)

print("Logistic Regression Metrics:")

print(f"Accuracy: {log_reg_metrics[0]}, Precision: {log_reg_metrics[1]}, Recall: {log_reg_metrics[2]}, F1
Score: {log_reg_metrics[3]}")

print("\nDecision Tree Metrics:")

print(f"Accuracy: {tree_metrics[0]}, Precision: {tree_metrics[1]}, Recall: {tree_metrics[2]}, F1 Score:
{tree_metrics[3]}")

# Comparison of models
if log_reg_metrics[3] > tree_metrics[3]:
best_model = "Logistic Regression"
best_metrics = log_reg_metrics
else:
best_model = "Decision Tree"
best_metrics = tree_metrics
print(f"\nBest model: {best_model} with F1 Score: {best_metrics[3]}")

Q10)
# Import necessary libraries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Load the dataset

data = pd.read_csv(’car_evaluation.csv’)

# Encode categorical features

# Define categorical columns
categorical_columns = [’buying’, ’maint’, ’doors’, ’persons’, ’lug_boot’, ’safety’]

# Use One-Hot Encoding

encoder = OneHotEncoder(drop=’first’, sparse=False) # Drop one category to avoid multicollinearity
encoded_features = encoder.fit_transform(data[categorical_columns])

# Convert the encoded array back to a DataFrame

encoded_df = pd.DataFrame(encoded_features,
columns=encoder.get_feature_names(categorical_columns))

# Drop original categorical columns and concatenate with encoded features

data = data.drop(categorical_columns, axis=1)
data = pd.concat([data, encoded_df], axis=1)

# Split the data into features (X) and target (y)

X = data.drop(’class’, axis=1)
y = data[’class’]

# Split data into training and testing sets (80% training, 20% testing)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a Logistic Regression model

model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)

# Predict on the test set

y_pred = model.predict(X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average=’weighted’)
recall = recall_score(y_test, y_pred, average=’weighted’)
f1 = f1_score(y_test, y_pred, average=’weighted’)

# Print the evaluation metrics

print(f"Accuracy: {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1 Score: {f1:.4f}")