import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("titanic.csv")
print("Dataset head:")
print(df.head())
print("\n Data info:")
print(df.info)
print("Dataset Description:")
print(df.describe())
print("\n Dataset shape:")
print(df.shape)
print("\n column names")
print(df.columns)
print("\n missing values:")
print(df.isnull().sum())
print("\n Basic Data Visualization:")
df.hist(figsize=(10,8))
plt.show
print(df["Age"])

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest, f_classif, RFE
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

iris = load_iris()
x = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)
model = RandomForestClassifier(random_state=42)

print("Univariate Feature Selection:")
selector = SelectKBest(score_func=f_classif, k=2)
x_new = selector.fit_transform(x_train, y_train)
print("Feature score:", selector.scores_)
print("Select Features:", x_train.columns[selector.get_support()])

print("\n Recursive Feature Elimination(RFE):")
rfe = RFE(estimator=model, n_features_to_select=2)
rfe.fit(x_train, y_train)
print("Selected features:", x_train.columns[rfe.support_])

print("\n Feature Importance from Random Forest:")
model.fit(x_train, y_train)
importances = model.feature_importances_
indices = np.argsort(importances)[::-1]
print("Feature Ranking:")
for f in range(x_train.shape[1]):
    print(f"{x_train.columns[indices[f]]}: {importances[indices[f]]}")

import pandas as pd
import numpy as np

data = pd.DataFrame({
    'age': [25, np.nan, 30, 45, np.nan],
    'salary': [50000, 60000, np.nan, 65000, 70000],
    'city': ['New York', 'Los Angeles', 'New York', 'San Francisco', np.nan],
    'target': [1, 0, 1, 0, 1]
})
print("Original Data:")
print(data)
print("Missing values:")
print(data.isnull().sum())
print("percentage of Missing values:")
print(data.isnull().mean() * 100)

data = data.dropna()
print('after removing rows')
print(data)

from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, LabelEncoder

cat_features = ['city']
label_encoders = {}
for col in cat_features:
    le = LabelEncoder()
    data[col] = le.fit_transform(data[col])
    label_encoders[col] = le

scaler = StandardScaler()
num_features = ['age', 'salary']
data[num_features] = scaler.fit_transform(data[num_features])

data.to_csv('cleaned_dataset.csv', index=False)
data1 = pd.read_csv('cleaned_dataset.csv')
print('df to csv')
print(data1)

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.metrics import confusion_matrix

iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=50)

model = KNeighborsClassifier(n_neighbors=9)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='macro')
recall = recall_score(y_test, y_pred, average='macro')
cm = confusion_matrix(y_test, y_pred)

positive_rate = sum(y_test == 1) / len(y_test)
if positive_rate != 0:
    lift = precision / positive_rate
else:
    lift = 0

print("Accuracy :", accuracy)
print("Precision:", precision)
print("Recall :", recall)
print("Lift Measure:", lift)
print("\nConfusion Matrix:")
print(cm)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
y = iris.target

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn import svm
kernels = ['linear', 'poly', 'rbf', 'sigmoid']
models = {}
for kernel in kernels:
    model = svm.SVC(kernel=kernel)
    model.fit(X_train, y_train)
    models[kernel] = model
    y_pred = model.predict(X_test)

from sklearn.metrics import classification_report, confusion_matrix
print(f"Kernel: {kernel}")
print(classification_report(y_test, y_pred, target_names=iris.target_names, zero_division=0))
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))
print("*"*100)

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=7)
knn.fit(X_train, y_train)
print("KNN = ", knn.score(X_test, y_test))

from sklearn.svm import SVC
model = SVC()
model.fit(X_train, y_train)
print("SVM=", model.score(X_test, y_test))

from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier()
tree.fit(X_train, y_train)
print("DT=", tree.score(X_test, y_test))

from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(n_estimators=5, random_state=0)
forest.fit(X_train, y_train)
print("RF=", forest.score(X_test, y_test))

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
logreg.fit(X_train, y_train)
print("Logistic = ", logreg.score(X_test, y_test))

from sklearn.naive_bayes import GaussianNB
nb = GaussianNB().fit(X_train, y_train)
print("Naive=", nb.score(X_test, y_test))

import numpy as np
from sklearn.cluster import DBSCAN
import matplotlib.pyplot as plt

np.random.seed(42)
X = np.random.randn(50, 2)
X = np.vstack([X, np.random.uniform(low=-6, high=6, size=(20, 2))])

dbscan = DBSCAN(eps=0.5, min_samples=5)
labels = dbscan.fit_predict(X)

plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', marker='o', s=50)
plt.title('DBSCAN Clustering')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Cluster Label')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans, DBSCAN
from sklearn.metrics import silhouette_score, davies_bouldin_score

np.random.seed(42)
X = np.random.randn(40, 2)

kmeans = KMeans(n_clusters=4, random_state=42)
kmeans_labels = kmeans.fit_predict(X)
kmeans_silhouette = silhouette_score(X, kmeans_labels)
kmeans_dbi = davies_bouldin_score(X, kmeans_labels)

dbscan = DBSCAN(eps=0.5, min_samples=5)
dbscan_labels = dbscan.fit_predict(X)
dbscan_silhouette = silhouette_score(X, dbscan_labels)
dbscan_dbi = davies_bouldin_score(X, dbscan_labels)

print("K-Means Results")
print("Silhouette Score:", kmeans_silhouette)
print("Davies-Bouldin Score:", kmeans_dbi)
print("\nDBSCAN Results")
print("Silhouette Score:", dbscan_silhouette)
print("Davies-Bouldin Score:", dbscan_dbi)

plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=kmeans_labels, cmap='viridis')
plt.title("K-Means Clustering")
plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=dbscan_labels, cmap='viridis')
plt.title("DBSCAN Clustering")
plt.show()

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
import matplotlib.pyplot as plt

iris = load_iris()
x = iris.data
y = iris.target
df = pd.DataFrame(data=x, columns=iris.feature_names)
df['target'] = y
print(df.head())

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
clf = DecisionTreeClassifier(criterion='entropy', random_state=42)
clf.fit(x_train, y_train)
y_pred = clf.predict(x_test)
accuracy = clf.score(x_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

plt.figure(figsize=(12, 8))
plot_tree(clf, filled=True, feature_names=iris.feature_names, class_names=iris.target_names, rounded=True)
plt.title("Decision Tree using ID3 Algorithm")
plt.show()

tree_structure = export_text(clf, feature_names=iris.feature_names)
print(tree_structure)

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

iris = datasets.load_iris()
x = iris.data
y = iris.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)

mlp = MLPClassifier(hidden_layer_sizes=(10,), max_iter=2000,
                     activation='relu', solver='adam', random_state=42)
mlp.fit(x_train, y_train)
y_pred = mlp.predict(x_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy*100:.2f}%")

# dataset: NaiveBayes_Data.csv
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import accuracy_score

data = pd.read_csv('NaiveBayes_Data.csv')
print("First few rows of the datasets:")
print(data.head())
print(data.columns)

x = data.drop(columns=['diabetes'], axis=1)
y = data['diabetes']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=12)

model = GaussianNB()
model.fit(x_train, y_train)
y_pred = model.predict(x_test)

cm = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:\n", cm)
print("classification report", classification_report(y_test, y_pred))

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy of the naive Bayes Classifier:{accuracy*100:.2f}%")

results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})
print("\n Comparsion of actual and predicted label:")
print(results.head(5))

import numpy as np
import gymnasium as gym
import random
import matplotlib.pyplot as plt

env = gym.make('Taxi-v4')
q_table = np.zeros([env.observation_space.n, env.action_space.n])

alpha = 0.1
gamma = 0.99
epsilon = 0.1
episodes = 1000
exploration_decay = 0.999
min_eps = 0.1
rewards = []

for episode in range(episodes):
    state, _ = env.reset()
    total_reward = 0
    done = False
    while not done:
        if random.uniform(0, 1) < epsilon:
            action = env.action_space.sample()
        else:
            action = np.argmax(q_table[state])
        next_state, reward, terminated, truncated, _ = env.step(action)
        done = terminated or truncated
        best_next_action = np.argmax(q_table[next_state])
        q_table[state, action] += alpha * (reward + gamma *
            q_table[next_state, best_next_action] - q_table[state, action])
        state = next_state
        total_reward += reward
    epsilon = max(min_eps, epsilon * exploration_decay)
    rewards.append(total_reward)

plt.plot(rewards)
plt.title('Total Rewards per Episode')
plt.xlabel('Episode')
plt.ylabel('Total Reward')
plt.show()
print("Q-table:")
print(q_table)

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))
x_train, x_test = x_train / 255.0, x_test / 255.0

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=3, batch_size=64, validation_data=(x_test, y_test))

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f"Test accuracy: {test_acc * 100:.2f}%")

predictions = model.predict(x_test)
for i in range(3):
    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')
    plt.title(f"Predicted: {predictions[i].argmax()} | True: {y_test[i]}")
    plt.show()