Start coding or generate with AI.

Double-click (or enter) to edit

chatgpt

# Import necessary libraries

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris

# Load the Iris dataset from sklearn

iris_sklearn = load_iris()
# Convert to a pandas DataFrame
iris_df = pd.DataFrame(data=iris_sklearn.data, columns=iris_sklearn.feature_names)
# Add the target variable
iris_df['species'] = pd.Categorical.from_codes(iris_sklearn.target, iris_sklearn.target_names)

# Display the first 5 rows of the dataset

print(iris_df.head())

# Identify features and labels

features = iris_df.columns[:-1]
label = iris_df.columns[-1]
print(f"Features: {features}")
print(f"Label: {label}")

# Plot the distribution of each feature using histograms

iris_df[features].hist(figsize=(10, 8))
plt.suptitle('Feature Distributions')
plt.show()

# Visualize the dataset using a scatterplot matrix

sns.pairplot(iris_df, hue='species', markers=["o", "s", "D"])
plt.suptitle('Scatterplot Matrix')
plt.show()
 sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) \
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
3 4.6 3.1 1.5 0.2
4 5.0 3.6 1.4 0.2

species
0 setosa
1 setosa
2 setosa
3 setosa
4 setosa
Features: Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',
'petal width (cm)'],
dtype='object')
Label: species
# Part 1: Statistical Features and Feature Selection

# Step 1: Import necessary libraries

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# Load the Iris dataset

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# Step 2: Compute statistical features

statistical_summary = {
'Mean': iris_df.mean(),
'Median': iris_df.median(),
'Variance': iris_df.var(),
'Standard Deviation': iris_df.std(),
'Minimum': iris_df.min(),
'Maximum': iris_df.max()
}

# Convert to DataFrame for better visualization

statistical_summary_df = pd.DataFrame(statistical_summary)
print("Statistical Features:\n", statistical_summary_df)

# Step 3: Normalize the features

# Min-Max Scaling
min_max_scaler = MinMaxScaler()
iris_df_minmax = pd.DataFrame(min_max_scaler.fit_transform(iris_df), columns=iris.feature_names)

# Z-score Normalization
z_score_scaler = StandardScaler()
iris_df_zscore = pd.DataFrame(z_score_scaler.fit_transform(iris_df), columns=iris.feature_names)

# Display normalized data

print("\nMin-Max Normalized Data:\n", iris_df_minmax.head())
print("\nZ-score Normalized Data:\n", iris_df_zscore.head())

# Step 4: Discussing feature relevance

# Based on the statistical properties, we can discuss the relevance of features
# For example, we can look at the variance and mean values to determine which features are more spread out and have higher v

feature_relevance = {
'Feature': iris.feature_names,
'Mean': statistical_summary_df['Mean'],
'Variance': statistical_summary_df['Variance']
}

feature_relevance_df = pd.DataFrame(feature_relevance)
print("\nFeature Relevance based on Mean and Variance:\n", feature_relevance_df)

# Discussion on feature relevance

print("\nDiscussion on Feature Relevance:")
for index, row in feature_relevance_df.iterrows():
 print(f"{row['Feature']}: Mean = {row['Mean']:.2f}, Variance = {row['Variance']:.2f}")
if row['Variance'] > 0.5: # Arbitrary threshold for variance
print(f" - This feature has a relatively high variance, indicating it may be useful for classification.")
else:
print(f" - This feature has a low variance, indicating it may not be very useful for classification.")

Statistical Features:
Mean Median Variance Standard Deviation Minimum \
sepal length (cm) 5.843333 5.80 0.685694 0.828066 4.3
sepal width (cm) 3.057333 3.00 0.189979 0.435866 2.0
petal length (cm) 3.758000 4.35 3.116278 1.765298 1.0
petal width (cm) 1.199333 1.30 0.581006 0.762238 0.1

Maximum
sepal length (cm) 7.9
sepal width (cm) 4.4
petal length (cm) 6.9
petal width (cm) 2.5

Min-Max Normalized Data:

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 0.222222 0.625000 0.067797 0.041667
1 0.166667 0.416667 0.067797 0.041667
2 0.111111 0.500000 0.050847 0.041667
3 0.083333 0.458333 0.084746 0.041667
4 0.194444 0.666667 0.067797 0.041667

Z-score Normalized Data:

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 -0.900681 1.019004 -1.340227 -1.315444
1 -1.143017 -0.131979 -1.340227 -1.315444
2 -1.385353 0.328414 -1.397064 -1.315444
3 -1.506521 0.098217 -1.283389 -1.315444
4 -1.021849 1.249201 -1.340227 -1.315444

Feature Relevance based on Mean and Variance:

Feature Mean Variance
sepal length (cm) sepal length (cm) 5.843333 0.685694
sepal width (cm) sepal width (cm) 3.057333 0.189979
petal length (cm) petal length (cm) 3.758000 3.116278
petal width (cm) petal width (cm) 1.199333 0.581006

Discussion on Feature Relevance:

sepal length (cm): Mean = 5.84, Variance = 0.69
- This feature has a relatively high variance, indicating it may be useful for classification.
sepal width (cm): Mean = 3.06, Variance = 0.19
- This feature has a low variance, indicating it may not be very useful for classification.
petal length (cm): Mean = 3.76, Variance = 3.12
- This feature has a relatively high variance, indicating it may be useful for classification.
petal width (cm): Mean = 1.20, Variance = 0.58
- This feature has a relatively high variance, indicating it may be useful for classification.

# pattern recognation

# Part 2: Pattern Recognition

# Step 1: Import necessary libraries

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

# Load the Iris dataset

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
iris_df['species'] = iris.target

# Step 2: Data Splitting

# Split the dataset into training and testing sets (70% training, 30% testing)
X = iris_df[iris.feature_names]
y = iris_df['species']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Normalize the features

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

# Step 3: Model Implementation

# K-Nearest Neighbors (KNN)
knn_params = {'n_neighbors': range(1, 21)}
knn_grid = GridSearchCV(KNeighborsClassifier(), knn_params, cv=5)
knn_grid.fit(X_train_scaled, y_train)

# Support Vector Machine (SVM)

svm_params = {'kernel': ['linear', 'rbf', 'poly'], 'C': [0.1, 1, 10]}
svm_grid = GridSearchCV(SVC(), svm_params, cv=5)
svm_grid.fit(X_train_scaled, y_train)

# Step 4: Evaluation
# Evaluate KNN
knn_best = knn_grid.best_estimator_
y_pred_knn = knn_best.predict(X_test_scaled)

# Evaluate SVM
svm_best = svm_grid.best_estimator_
y_pred_svm = svm_best.predict(X_test_scaled)

# Calculate metrics
metrics = {
'Model': ['KNN', 'SVM'],
'Accuracy': [accuracy_score(y_test, y_pred_knn), accuracy_score(y_test, y_pred_svm)],
'Precision': [precision_score(y_test, y_pred_knn, average='weighted'), precision_score(y_test, y_pred_svm, average='weigh
'Recall': [recall_score(y_test, y_pred_knn, average='weighted'), recall_score(y_test, y_pred_svm, average='weighted')],
'F1 Score': [f1_score(y_test, y_pred_knn, average='weighted'), f1_score(y_test, y_pred_svm, average='weighted')]
}

metrics_df = pd.DataFrame(metrics)
print("\nEvaluation Metrics:\n", metrics_df)

# Step 5: Plot confusion matrices

def plot_confusion_matrix(y_true, y_pred, model_name):
cm = confusion_matrix(y_true, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names)
plt.title(f'Confusion Matrix for {model_name}')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.show()

plot_confusion_matrix(y_test, y_pred_knn, 'KNN')

plot_confusion_matrix(y_test, y_pred_svm, 'SVM')
 Evaluation Metrics:
Model Accuracy Precision Recall F1 Score
0 KNN 1.000000 1.000000 1.000000 1.000000
1 SVM 0.977778 0.979365 0.977778 0.977745

# 4. Comparison and Conclusion

# Part 3: Model Comparison and Conclusion

# Step 1: Import necessary libraries

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

# Load the Iris dataset

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
iris_df['species'] = iris.target

# Step 2: Data Splitting

# Split the dataset into training and testing sets (70% training, 30% testing)
X = iris_df[iris.feature_names]
y = iris_df['species']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Normalize the features

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

# Step 3: Model Implementation

# K-Nearest Neighbors (KNN)
knn_params = {'n_neighbors': range(1, 21)}
knn_grid = GridSearchCV(KNeighborsClassifier(), knn_params, cv=5)
knn_grid.fit(X_train_scaled, y_train)

# Support Vector Machine (SVM)

svm_params = {'kernel': ['linear', 'rbf', 'poly'], 'C': [0.1, 1, 10]}
svm_grid = GridSearchCV(SVC(), svm_params, cv=5)
svm_grid.fit(X_train_scaled, y_train)

# Step 4: Evaluation
# Evaluate KNN
knn_best = knn_grid.best_estimator_
y_pred_knn = knn_best.predict(X_test_scaled)

# Evaluate SVM
svm_best = svm_grid.best_estimator_
y_pred_svm = svm_best.predict(X_test_scaled)

# Calculate metrics
metrics = {
'Model': ['KNN', 'SVM'],
'Accuracy': [accuracy_score(y_test, y_pred_knn), accuracy_score(y_test, y_pred_svm)],
'Precision': [precision_score(y_test, y_pred_knn, average='weighted'), precision_score(y_test, y_pred_svm, average='weig
'Recall': [recall_score(y_test, y_pred_knn, average='weighted'), recall_score(y_test, y_pred_svm, average='weighted')],
'F1 Score': [f1_score(y_test, y_pred_knn, average='weighted'), f1_score(y_test, y_pred_svm, average='weighted')]
}

metrics_df = pd.DataFrame(metrics)
print("\nEvaluation Metrics:\n", metrics_df)

# Step 5: Plotting the comparison

metrics_df.set_index('Model').plot(kind='bar', figsize=(10, 6))
plt.title('Model Comparison')
plt.ylabel('Score')
plt.xticks(rotation=0)
plt.ylim(0, 1)
plt.grid(axis='y')
plt.show()

# Step 6: Discussion
best_model = metrics_df.loc[metrics_df['Accuracy'].idxmax()]
print("\nBest Model:")
print(f"Model: {best_model['Model']}")
print(f"Accuracy: {best_model['Accuracy']:.2f}")
print(f"Precision: {best_model['Precision']:.2f}")
print(f"Recall: {best_model['Recall']:.2f}")
print(f"F1 Score: {best_model['F1 Score']:.2f}")
 Evaluation Metrics:
Model Accuracy Precision Recall F1 Score
0 KNN 1.000000 1.000000 1.000000 1.000000
1 SVM 0.977778 0.979365 0.977778 0.977745

Best Model:
Model: KNN
Accuracy: 1.00
Precision: 1.00
Recall: 1.00
F1 Score: 1.00

# delivarables:

# Part 1: Feature Extraction and Statistical Analysis

# Step 1: Import necessary libraries

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# Load the Iris dataset

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# Step 2: Compute statistical features

statistical_summary = {
'Mean': iris_df.mean(),
'Median': iris_df.median(),
'Variance': iris_df.var(),
'Standard Deviation': iris_df.std(),
'Minimum': iris_df.min(),
'Maximum': iris_df.max()
}

# Convert to DataFrame for better visualization

statistical_summary_df = pd.DataFrame(statistical_summary)
#print("Statistical Features:\n", statistical_summary_df)

# Step 3: Normalize the features

# Min-Max Scaling
min_max_scaler = MinMaxScaler()
iris_df_minmax = pd.DataFrame(min_max_scaler.fit_transform(iris_df), columns=iris.feature_names)

# Z-score Normalization
z_score_scaler = StandardScaler()
iris_df_zscore = pd.DataFrame(z_score_scaler.fit_transform(iris_df), columns=iris.feature_names)

# Display normalized data

#print("\nMin-Max Normalized Data:\n", iris_df_minmax.head())