Notes

https://github.com/RoshanUpadhyay02/Design-of-Artificial-Intelligence-Products
========================================================================================================================

A) naive bayes with cm and heatmap

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, confusion_matrix

# Load the Breast Cancer dataset
data = load_breast_cancer()

# Split the dataset into training and testing data
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.3, random_state=42)

# Create a Gaussian Naive Bayes classifier
clf = GaussianNB()

# Train the classifier on the training data
clf.fit(X_train, y_train)

# Make predictions on the testing data
y_pred = clf.predict(X_test)

# Print the accuracy score and confusion matrix
print("Accuracy:", accuracy_score(y_test, y_pred))
print("Confusion Matrix:n", confusion_matrix(y_test, y_pred))

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

# assume y_true and y_pred are already defined from previous code
cm = confusion_matrix(y_test, y_pred)

# plot confusion matrix as heatmap
sns.heatmap(cm, annot=True, cmap='Blues')
plt.title('Confusion Matrix')
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.show()

========================================================================================================================

B) CIFAR10 (use gpu for faster compile)

import tensorflow as tf
from tensorflow import keras
from keras.datasets import cifar10
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np

# Load CIFAR-10 dataset
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# Normalize pixel values to be between 0 and 1
x_train = x_train / 255.0
x_test = x_test / 255.0

# Define the model
model = Sequential()
model.add(Conv2D(32, (3,3), activation='relu', padding='same', input_shape=(32,32,3)))
model.add(Conv2D(32, (3,3), activation='relu', padding='same'))
model.add(MaxPooling2D((2,2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3,3), activation='relu', padding='same'))
model.add(Conv2D(64, (3,3), activation='relu', padding='same'))
model.add(MaxPooling2D((2,2)))
model.add(Dropout(0.25))

model.add(Conv2D(128, (3,3), activation='relu', padding='same'))
model.add(Conv2D(128, (3,3), activation='relu', padding='same'))
model.add(MaxPooling2D((2,2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

# Compile the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Train the model
model.fit(x_train, y_train, epochs=10, batch_size=64)

# Evaluate the model on test set
test_loss, test_acc = model.evaluate(x_test, y_test)
print("Test accuracy:", test_acc)

# Make predictions on test set
y_pred = model.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)

# Print confusion matrix and classification report
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))
print("Classification Report:")
print(classification_report(y_test, y_pred))

========================================================================================================================


C) Regression with generalization

# Importing necessary libraries
import pandas as pd
import numpy as np
from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt

# Loading the dataset
diabetes = load_diabetes()

# Creating dataframe
df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
df['target'] = diabetes.target

# Splitting the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.3, random_state=42)

# Creating linear regression object
lr = LinearRegression()

# Training the model
lr.fit(X_train, y_train)

# Predicting the target values
y_pred = lr.predict(X_test)

# Calculating various metrics
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
adj_r2 = 1 - ((1 - r2) * (len(y_test) - 1)) / (len(y_test) - X_test.shape[1] - 1)

# Printing the metrics
print('MSE:', mse)
print('RMSE:', rmse)
print('R-squared:', r2)
print('Adjusted R-squared:', adj_r2)

# Creating confusion matrix and heatmap
y_pred_class = np.where(y_pred > np.mean(y_pred), 1, 0)
confusion_matrix = pd.crosstab(y_test > np.mean(y_test), y_pred_class, rownames=['Actual'], colnames=['Predicted'])




sns.heatmap(confusion_matrix, annot=True, cmap='Blues')
plt.show()

========================================================================================================================

D) Binary CLassifiaction


# Import required libraries
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression




from sklearn.metrics import accuracy_score, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Load the dataset
data = load_breast_cancer()

# Create a DataFrame for the dataset
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df[data.feature_names], df['target'], random_state=0)

# Create a logistic regression object
lr = LogisticRegression()

# Train the logistic regression model
lr.fit(X_train, y_train)

# Predict the test set labels using the trained model
y_pred = lr.predict(X_test)

# Calculate the accuracy of the model
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

# Create a confusion matrix
cm = confusion_matrix(y_test, y_pred)
print('Confusion Matrix:n', cm)

# Create a heatmap of the confusion matrix
sns.heatmap(cm, annot=True, cmap='Blues')
plt.xlabel('Predicted labels')
plt.ylabel('True labels')
plt.show()

========================================================================================================================

E) 3x3 magic square (ive used gridworld navigation from reinforcement learning lab, so mightt not be correct)

!pip install gym[toy_text]

# importing libraries
import gym
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import clear_output

# Creating Custom Map
# S -> Starting position / Initial Robot Position
# F -> Path
# H -> Obstacle / Hole
# G -> Home / Destination / Docking Station / Goal

custom_map = [
"SFFF",
"FHFH",
"FFFH",
"HFFG"
]

# Creating Environment
env=gym.make('FrozenLake-v1', desc= custom_map , is_slippery=False)
env.reset()

action_space = env.action_space.n
observation_space = env.observation_space.n

print(f"action_space = {action_space} observation_space = {observation_space}")

# We re-initialize the Q-table
qtable = np.zeros((observation_space, action_space))
print('Q-table before training:n')
print(qtable)
print("n")

# Hyperparameters
episodes = 1000 # Total number of episodes
alpha = 0.5 # Learning rate
gamma = 0.9 # Discount factor

# List of outcomes to plot
outcomes = []

# Training
for _ in range(episodes):
state = env.reset()
done = False

# By default, we consider our outcome to be a failure
outcomes.append("Failure")

# Until the agent gets stuck in a hole or reaches the goal, keep training it
while not done:
# Choose the action with the highest value in the current state
if np.max(qtable[state]) > 0:
action = np.argmax(qtable[state])

# If there's no best action (only zeros), take a random one
else:
action = env.action_space.sample()

# Implement this action and move the agent in the desired direction
new_state, reward, done, info = env.step(action)

# Update Q(s,a)
qtable[state, action] = qtable[state, action] +
alpha * (reward + gamma * np.max(qtable[new_state]) - qtable[state, action])

# Update our current state
state = new_state

# If we have a reward, it means that our outcome is a success
if reward:
outcomes[-1] = "Success"

print('Q-table after training:n')
print(qtable)
print("n")


# Plot outcomes
plt.rcParams['figure.dpi'] = 300
plt.rcParams.update({'font.size': 17})
plt.figure(figsize=(5, 2))
plt.xlabel("Run number")
plt.ylabel("Outcome")
ax = plt.gca()
ax.set_facecolor('#efeeea')
plt.bar(range(len(outcomes)), outcomes, color="#0A047A", width=1.0)
plt.show()

episodes = 1000000
nb_success = 0

# Evaluation
for _ in range(1000000):
clear_output()
state = env.reset()
done = False
print(f"Episode Completed = {_/episodes*100}%")

# Until the agent gets stuck or reaches the goal, keep training it
while not done:
# Choose the action with the highest value in the current state
if np.max(qtable[state]) > 0:
action = np.argmax(qtable[state])

# If there's no best action (only zeros), take a random one
else:
action = env.action_space.sample()

# Implement this action and move the agent in the desired direction
new_state, reward, done, info = env.step(action)

# Update our current state
state = new_state

# When we get a reward, it means we solved the game
nb_success += reward


# Let's check our success rate!
print (f"Success rate = {nb_success/episodes*100}%")

from IPython.display import clear_output
import time

state = env.reset()
done = False
sequence = []

while not done:
# Choose the action with the highest value in the current state
if np.max(qtable[state]) > 0:
action = np.argmax(qtable[state])

# If there's no best action (only zeros), take a random one
else:
action = env.action_space.sample()

# Add the action to the sequence
sequence.append(action)

# Implement this action and move the agent in the desired direction
new_state, reward, done, info = env.step(action)

# Update our current state
state = new_state

# Update the render
clear_output(wait=True)

time.sleep(1)

print(f"Sequence = {sequence}")

for i in sequence :
if i == 0 :
print("LEFT n")
elif i == 1 :
print("DOWN n")
elif i == 2 :
print("RIGHT n")
elif i == 3 :
print("UP n")
else :
print("error")

========================================================================================================================

F) Student Performance

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.decomposition import PCA
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.metrics import roc_auc_score

df = pd.read_csv('StudentsPerformance.csv')

le = LabelEncoder()
df['gender'] = le.fit_transform(df['gender'])
df['race/ethnicity'] = le.fit_transform(df['race/ethnicity'])
df['parental level of education'] = le.fit_transform(df['parental level of education'])
df['lunch'] = le.fit_transform(df['lunch'])
df['test preparation course'] = le.fit_transform(df['test preparation course'])

scaler = StandardScaler()
X = scaler.fit_transform(df)

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans_labels = kmeans.fit_predict(X_pca)

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], kmeans_labels))
print()

print('classifiaction Report')
print(classification_report(df['test preparation course'], kmeans_labels))

agg = AgglomerativeClustering(n_clusters=3)
agg_labels = agg.fit_predict(X_pca)

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], agg_labels))
print()

print('classifiaction Report')
print(classification_report(df['test preparation course'], agg_labels))

dbscan = DBSCAN(eps=1.2, min_samples=12)
dbscan_labels = dbscan.fit_predict(X_pca)

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], dbscan_labels))
print()

print('classifiaction Report')
print(classification_report(df['test preparation course'], dbscan_labels))

fig, ax = plt.subplots(1, 3, figsize=(15, 5))
fig.suptitle('Clustering Algorithms Comparison')

ax[0].scatter(X_pca[:, 0], X_pca[:, 1], c=kmeans_labels)
ax[0].set_title('KMeans Clustering')

ax[1].scatter(X_pca[:, 0], X_pca[:, 1], c=agg_labels)
ax[1].set_title('Agglomerative Clustering')

ax[2].scatter(X_pca[:, 0], X_pca[:, 1], c=dbscan_labels)
ax[2].set_title('DBSCAN Clustering')

plt.show()

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], kmeans_labels))
print('classifiaction Report')
print(classification_report(df['test preparation course'], kmeans_labels))
cm1=confusion_matrix(df['test preparation course'], kmeans_labels)
tp = cm1[0, 0]
tn = cm1[1, 1]
fp = cm1[1, 0]
fn = cm1[0, 1]
accuracy = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)
recall = tp / (tp + fn)
specificity = tn / (tn + fp)
f1score = 2 * precision * recall / (precision + recall)
roc=roc_auc_score(df['test preparation course'], kmeans_labels)

print('Accuracy:', accuracy)
print('precision:', precision)
print('recall:', recall)
print('specificity:', specificity)
print('f1score:', f1score)
print('roc:', roc)

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], agg_labels))
print('classifiaction Report')
print(classification_report(df['test preparation course'], agg_labels))
cm2=confusion_matrix(df['test preparation course'], agg_labels)
tp = cm2[0, 0]
tn = cm2[1, 1]
fp = cm2[1, 0]
fn = cm2[0, 1]
accuracy = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)
recall = tp / (tp + fn)
specificity = tn / (tn + fp)
f1score = 2 * precision * recall / (precision + recall)
roc=roc_auc_score(df['test preparation course'], agg_labels)

print('Accuracy:', accuracy)
print('precision:', precision)
print('recall:', recall)
print('specificity:', specificity)
print('f1score:', f1score)
print('roc:', roc)

print('confusion Martix')
print(confusion_matrix(df['test preparation course'], dbscan_labels))
print('classifiaction Report')
print(classification_report(df['test preparation course'], dbscan_labels))
cm3=confusion_matrix(df['test preparation course'], dbscan_labels)
tp = cm3[0, 0]
tn = cm3[1, 1]
fp = cm3[1, 0]
fn = cm3[0, 1]
accuracy = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)
recall = tp / (tp + fn)
specificity = tn / (tn + fp)
f1score = 2 * precision * recall / (precision + recall)
roc=roc_auc_score(df['test preparation course'], dbscan_labels)

print('Accuracy:', accuracy)
print('precision:', precision)
print('recall:', recall)
print('specificity:', specificity)
print('f1score:', f1score)
print('roc:', roc)

=========================================================================================
1. LINEAR REGRESSION:

from sklearn.linear_model import LinearRegression
# create a LinearRegression object
regressor = LinearRegression()
# define the input (X) and output (y) variables
X = [[1], [2], [3], [4], [5]]
y = [2, 4, 5, 4, 5]
# train the model using the input and output data
regressor.fit(X, y)
# print the model coefficients
print("Intercept:", regressor.intercept_)
print("Coefficient:", regressor.coef_)
# make a prediction for a new input value
new_X = [[6]]
predicted_y = regressor.predict(new_X)
print("Predicted output:", predicted_y)


2. Logistic Rgression

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
# create a classification dataset
X, y = make_classification(n_samples=1000, n_features=4, random_state=42)
# 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)
# create a LogisticRegression object
classifier = LogisticRegression()
# train the model using the training data
classifier.fit(X_train, y_train)
# evaluate the model accuracy on the testing data
accuracy = classifier.score(X_test, y_test)
print("Accuracy:", accuracy)
# make a prediction for a new input value
new_X = [[0.5, 0.5, 0.5, 0.5]]
predicted_y = classifier.predict(new_X)
print("Predicted output:", predicted_y)

3. KNN

from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
# create a classification dataset
X, y = make_classification(n_samples=1000, n_features=4, random_state=42)
# 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)
# create a KNeighborsClassifier object with k=3
classifier = KNeighborsClassifier(n_neighbors=3)
# train the model using the training data
classifier.fit(X_train, y_train)
# evaluate the model accuracy on the testing data
accuracy = classifier.score(X_test, y_test)
print("Accuracy:", accuracy)
# make a prediction for a new input value
new_X = [[0.5, 0.5, 0.5, 0.5]]
predicted_y = classifier.predict(new_X)
print("Predicted output:", predicted_y)

4.SVM

from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
# create a classification dataset
X, y = make_classification(n_samples=1000, n_features=4, random_state=42)
# 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)
# create an SVM classifier with a linear kernel
classifier = SVC(kernel='linear')
# train the model using the training data
classifier.fit(X_train, y_train)
# evaluate the model accuracy on the testing data
accuracy = classifier.score(X_test, y_test)
print("Accuracy:", accuracy)
# make a prediction for a new input value
new_X = [[0.5, 0.5, 0.5, 0.5]]
predicted_y = classifier.predict(new_X)
print("Predicted output:", predicted_y)

5. K-Means

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
# create a random dataset with 500 samples and 4 clusters
X, y = make_blobs(n_samples=500, centers=4, random_state=42)
# create a KMeans object with 4 clusters
kmeans = KMeans(n_clusters=4)
# fit the KMeans model to the data
kmeans.fit(X)
# get the cluster labels and cluster centers
labels = kmeans.labels_
centers = kmeans.cluster_centers_
# plot the data points with different colors for each cluster
plt.scatter(X[:, 0], X[:, 1], c=labels)
# plot the cluster centers as red stars
plt.scatter(centers[:, 0], centers[:, 1], marker='*', c='red', s=200)
plt.show()

6. Navie Bayes

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
# load the iris dataset
iris = load_iris()
# split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)
# create a Gaussian Naive Bayes classifier
gnb = GaussianNB()
# train the classifier using the training data
gnb.fit(X_train, y_train)
# make predictions on the testing data
y_pred = gnb.predict(X_test)
# calculate the accuracy of the classifier
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

7. Binary Classification using Logistc Regression

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression


from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
# load the breast cancer dataset
data = load_breast_cancer()
# split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)
# create a logistic regression classifier
lr = LogisticRegression()
# train the classifier using the training data
lr.fit(X_train, y_train)
# make predictions on the testing data
y_pred = lr.predict(X_test)
# calculate the accuracy, precision, recall, F1 score, and AUC-ROC of the classifier
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
auc_roc = roc_auc_score(y_test, y_pred)
print("Accuracy:", accuracy)
print("Precision:", precision)
print("Recall:", recall)
print("F1 score:", f1)
print("AUC-ROC score:", auc_roc)


8. Image-Processing

import tensorflow
import keras
import os
import glob
from skimage import io
import random
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
dataset_path = '/content/Animals'
class_names = ['Cheetah', 'Jaguar', 'Leopard', 'Lion','Tiger']
# apply glob module to retrieve files/pathnames
animal_path = os.path.join(dataset_path, class_names[1], '*')
animal_path = glob.glob(animal_path)
image = io.imread(animal_path[4])
# plotting the original image
i, (im1) = plt.subplots(1)
i.set_figwidth(15)
im1.imshow(image)
i, (im1, im2, im3, im4) = plt.subplots(1, 4, sharey=True)
i.set_figwidth(20)
im1.imshow(image) #Original image
im2.imshow(image[:, : , 0]) #Red
im3.imshow(image[:, : , 1]) #Green
im4.imshow(image[:, : , 2]) #Blue
i.suptitle('Original & RGB image channels')
#GREYSCALE CONVERSION
import skimage
gray_image = skimage.color.rgb2gray(image)
plt.imshow(gray_image, cmap = 'gray')
#normalisation
norm_image = (gray_image - np.min(gray_image)) / (np.max(gray_image) - np.min(gray_image))
plt.imshow(norm_image)
#DATA-AGUMENTATION
#1.ShiftingHorizontally
from numpy import expand_dims
from keras_preprocessing.image import load_img
from keras_preprocessing.image import img_to_array
from keras.preprocessing.image import ImageDataGenerator
# convert to numpy array
data = img_to_array(image)
# expand dimension to one sample
samples = expand_dims(image, 0)
# create image data augmentation generator
datagen = ImageDataGenerator(width_shift_range=[-200,200])
# create an iterator
it = datagen.flow(samples, batch_size=1)
fig, im = plt.subplots(nrows=1, ncols=3, figsize=(15,15))
# generate batch of images
for i in range(3):
# convert to unsigned integers
image = next(it)[0].astype('uint8')
# plot image
im[i].imshow(image)
#Flipping
datagen = ImageDataGenerator(horizontal_flip=True, vertical_flip=True)
# create an iterator
it = datagen.flow(samples, batch_size=1)
fig, im = plt.subplots(nrows=1, ncols=3, figsize=(15,15))
# generate batch of images
for i in range(3):
# convert to unsigned integers
image = next(it)[0].astype('uint8')
# plot image
im[i].imshow(image)
#Rotaion
datagen = ImageDataGenerator(rotation_range=20, fill_mode='nearest')
# create an iterator
it = datagen.flow(samples, batch_size=1)
fig, im = plt.subplots(nrows=1, ncols=3, figsize=(15,15))
# generate batch of images
for i in range(3):
# convert to unsigned integers
image = next(it)[0].astype('uint8')
# plot image
im[i].imshow(image)
#Changing the Brightness
datagen = ImageDataGenerator(brightness_range=[0.5,2.0])
it = datagen.flow(samples, batch_size=1)
fig, im = plt.subplots(nrows=1, ncols=3, figsize=(15,15))
# generate batch of images
for i in range(3):
# convert to unsigned integers
image = next(it)[0].astype('uint8')
# plot image
im[i].imshow(image)