`Viva Preparation Guide 
# Q9. Uber Fare Prediction Using PCA and EDA

# Step 1: Import Libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# Step 2: Load Dataset
df = pd.read_csv("uber.csv")

print(df.head())
print("Shape:", df.shape)
print(df.dtypes)
print(df.describe())

# Step 3: Check Missing and Duplicate Values
print("Null Values:\n", df.isnull().sum())
print("Duplicate Rows:", df.duplicated().sum())

df = df.dropna()
df = df.drop_duplicates()

# Step 4: Remove Invalid Records
df = df[
    (df["fare_amount"] > 0) &
    (df["passenger_count"] > 0) &
    (df["pickup_latitude"].between(-90, 90)) &
    (df["dropoff_latitude"].between(-90, 90)) &
    (df["pickup_longitude"].between(-180, 180)) &
    (df["dropoff_longitude"].between(-180, 180))
].copy()

# Step 5: Calculate Distance Using Haversine
def haversine(lat1, lon1, lat2, lon2):
    lat1, lon1, lat2, lon2 = np.radians([lat1, lon1, lat2, lon2])

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = np.sin(dlat / 2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon / 2)**2

    return 6371 * 2 * np.arcsin(np.sqrt(a))

df["distance"] = haversine(
    df["pickup_latitude"],
    df["pickup_longitude"],
    df["dropoff_latitude"],
    df["dropoff_longitude"]
)

df = df[df["distance"] > 0].copy()

 # Remove Outliers using IQR
for col in ["fare_amount", "distance"]:
    Q1 = df[col].quantile(0.25)
    Q3 = df[col].quantile(0.75)
    IQR = Q3 - Q1

    df = df[
        (df[col] >= Q1 - 1.5 * IQR) &
        (df[col] <= Q3 + 1.5 * IQR)
    ]


# Step 6: EDA Plots
sns.histplot(df["fare_amount"])
plt.title("Fare Distribution")
plt.show()

sns.boxplot(x=df["fare_amount"])
plt.title("Fare Outliers")
plt.show()

sns.scatterplot(
    data=df.sample(n=1000, random_state=42),
    x="distance",
    y="fare_amount",
    alpha=0.4
)
plt.title("Distance vs Fare")
plt.show()

# Step 7: Select Features and Target
X = df[[
    "pickup_latitude",
    "pickup_longitude",
    "dropoff_latitude",
    "dropoff_longitude",
    "passenger_count",
    "distance"
]]

y = df["fare_amount"]

# Step 8: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 9: Standardize Features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Step 10: Model Without PCA
model1 = LinearRegression()
model1.fit(X_train, y_train)
pred1 = model1.predict(X_test)

# Step 11: Apply PCA
pca = PCA(n_components=0.95)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

print("Original Features:", X_train.shape[1])
print("PCA Components:", pca.n_components_)

# Step 12: Model With PCA
model2 = LinearRegression()
model2.fit(X_train_pca, y_train)
pred2 = model2.predict(X_test_pca)

# Step 13: Compare Results
print("\nWithout PCA")
print("R2:", r2_score(y_test, pred1))
print("RMSE:", np.sqrt(mean_squared_error(y_test, pred1)))
print("MAE:", mean_absolute_error(y_test, pred1))

print("\nWith PCA")
print("R2:", r2_score(y_test, pred2))
print("RMSE:", np.sqrt(mean_squared_error(y_test, pred2)))
print("MAE:", mean_absolute_error(y_test, pred2))

# Step 14: Simple Comparison Plot
plt.bar(
    ["Without PCA", "With PCA"],
    [r2_score(y_test, pred1), r2_score(y_test, pred2)]
)
plt.ylabel("R2 Score")
plt.title("R2 Score Comparison")
plt.show()

# Conclusion
print("PCA reduces the number of features.")
print("Compare R2, RMSE and MAE to evaluate model performance.")






# Q10. House Price Prediction Using Linear Regression

# Step 1: Import Libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# Step 2: Load Dataset
df = pd.read_csv("train.csv")

print(df.head())
print("Shape:", df.shape)
print(df.dtypes)
print(df.describe())

# Step 3: Check Missing and Duplicate Values
print("Null Values:\n", df.isnull().sum())
print("Duplicate Rows:", df.duplicated().sum())

# Remove Null and Duplicate Rows
df = df.drop_duplicates()
# Handle missing values
df = df.fillna(df.median(numeric_only=True))
df = df.fillna(df.mode().iloc[0])

df = pd.get_dummies(df) 
# Step 4: EDA
sns.histplot(df["SalePrice"], kde=True)
plt.title("House Price Distribution")
plt.show()

sns.scatterplot(data=df, x="GrLivArea", y="SalePrice")
plt.title("Living Area vs House Price")
plt.show()

# Step 5: Select Features and Target
X = df[["GrLivArea", "BedroomAbvGr", "FullBath", "OverallQual"]]
y = df["SalePrice"]

# Step 6: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 7: Train Linear Regression Model
model = LinearRegression()
model.fit(X_train, y_train)

# Step 8: Predict House Prices
y_pred = model.predict(X_test)

print("\nPredicted Prices:\n", y_pred[:10])

# Step 9: Evaluate Model
print("\nR2 Score:", r2_score(y_test, y_pred))
print("RMSE:", np.sqrt(mean_squared_error(y_test, y_pred)))
print("MAE:", mean_absolute_error(y_test, y_pred))

# Step 10: Actual vs Predicted Plot
plt.scatter(y_test, y_pred)
plt.xlabel("Actual Prices")
plt.ylabel("Predicted Prices")
plt.title("Actual vs Predicted House Prices")
plt.show()

correlation=['Price','Area','Bedrooms','Bathrooms', 'Floors','YearBuilt','Location','Condition','Garage']

sns.heatmap(round(df[correlation].corr(),2),annot=True,cmap='coolwarm')

# Conclusion
print("Linear Regression predicts house prices using property features.")
print("Higher R2 and lower RMSE and MAE indicate better performance.")


















# Q11. Student Performance Prediction Using Regression

# Step 1: Import Libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# Step 2: Load Dataset
df = pd.read_csv("student-mat.csv", sep=";")

print(df.head())
print("Shape:", df.shape)
print(df.dtypes)
print(df.describe())

# Step 3: Check Missing and Duplicate Values
print("Null Values:\n", df.isnull().sum())
print("Duplicate Rows:", df.duplicated().sum())

# Remove Null and Duplicate Rows
df = df.dropna()
df = df.drop_duplicates()

# Step 4: EDA
sns.scatterplot(data=df, x="studytime", y="G3")
plt.title("Study Time vs Final Marks")
plt.show()

sns.scatterplot(data=df, x="absences", y="G3")
plt.title("Absences vs Final Marks")
plt.show()

sns.scatterplot(data=df, x="G1", y="G3")
plt.title("Previous Marks vs Final Marks")
plt.show()

# Step 5: Select Features and Target
X = df[["studytime", "absences", "G1", "G2"]]
y = df["G3"]

# Step 6: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 7: Train Linear Regression Model
model = LinearRegression()
model.fit(X_train, y_train)

# Step 8: Predict Student Marks
y_pred = model.predict(X_test)
print("\nPredicted Marks:\n", y_pred[:10])

# Step 9: Evaluate Model
print("\nR2 Score:", r2_score(y_test, y_pred))
print("RMSE:", np.sqrt(mean_squared_error(y_test, y_pred)))
print("MAE:", mean_absolute_error(y_test, y_pred))

# Step 10: Identify Important Features
plt.bar(X.columns, model.coef_)
plt.show()


# Step 11: Actual vs Predicted Plot
plt.scatter(y_test, y_pred)
plt.xlabel("Actual Marks")
plt.ylabel("Predicted Marks")
plt.title("Actual vs Predicted Student Marks")
plt.show()

# Conclusion
print("Linear Regression predicts final marks using student attributes.")
print("Positive coefficients increase predicted marks, while negative")
print("coefficients decrease predicted marks, keeping other features fixed.")

new = [
    ['female', 'group B', "bachelor's degree", 'standard', 'completed',
     70, 80],
    ['male', 'group C', 'high school', 'free/reduced', 'none',
     60, 65],
    ['female', 'group A', "associate's degree", 'standard', 'none',
     85, 90]
]

ans = model.predict(new)
print(ans)




# Q12. Salary Estimation Using Linear Regression

# Step 1: Import Libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error

# Step 2: Create Dataset OR Read CSV File

# Option 1: Create Dataset
df = pd.DataFrame({
    "Experience": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    "Salary": [25000, 30000, 35000, 40000, 45000,
               50000, 55000, 60000, 65000, 70000]
})

# Option 2: Read Dataset from CSV
# df = pd.read_csv("Salary_Data.csv")

print(df.head())
print("Shape:", df.shape)
print(df.dtypes)
print(df.describe())

# Step 3: Check Missing and Duplicate Values
print("Null Values:\n", df.isnull().sum())
print("Duplicate Rows:", df.duplicated().sum())

# Remove Null and Duplicate Rows
df = df.dropna()
df = df.drop_duplicates()

# Step 4: Visualize Data
plt.scatter(df["Experience"], df["Salary"])
plt.xlabel("Years of Experience")
plt.ylabel("Salary")
plt.title("Experience vs Salary")
plt.show()

# Step 5: Select Features and Target
X = df[["Experience"]]
y = df["Salary"]

# Step 6: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 7: Train Linear Regression Model
model = LinearRegression()
model.fit(X_train, y_train)

# Step 8: Display Regression Equation
m = model.coef_[0]
c = model.intercept_

print("\nRegression Equation: Salary =", m, "* Experience +", c)

# Step 9: Display Regression Line
plt.scatter(X, y, label="Actual Salary")
plt.plot(X, model.predict(X), color="red", label="Regression Line")
plt.xlabel("Years of Experience")
plt.ylabel("Salary")
plt.title("Salary Prediction")
plt.legend()
plt.show()

# Step 10: Evaluate Model
y_pred = model.predict(X_test)

# Step 10: Predict Salary for User Input
x = float(input())
y = model.predict(pd.DataFrame({"Experience": [x]}))
print(y)


print("\nR2 Score:", r2_score(y_test, y_pred))
print("RMSE:", np.sqrt(mean_squared_error(y_test, y_pred)))
print("MAE:", mean_absolute_error(y_test, y_pred))

# Conclusion
print("Linear Regression estimates salary based on experience.")


# Q13. Compare Regression Models With and Without PCA

Same as Q9













# Q14. Loan Approval Prediction Using Decision Tree
pip install openpyxl
# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.metrics import f1_score, confusion_matrix, classification_report

# Step 2: Create Dataset OR Read CSV File

# df = pd.read_csv("loan_data.csv")

# If using a CSV, make sure the target column is named Loan_Status.
# Common Loan_Status values are Y/N or Approved/Rejected.

print(df.head())
print("\nDataset Shape:", df.shape)
print("\nMissing Values:\n", df.isnull().sum())

# Step 3: Handle Missing Values
for col in df.columns:
    if df[col].dtype == "object":
        df[col] = df[col].fillna(df[col].mode()[0])
    else:
        df[col] = df[col].fillna(df[col].median())

df = df.drop_duplicates()

# Step 4: Encode Categorical Variables
le = LabelEncoder()

for col in df.select_dtypes(include="object").columns:
    df[col] = le.fit_transform(df[col])

# Step 5: Select Features and Target
X = df.drop("Loan_Status", axis=1)
y = df["Loan_Status"]

# Step 6: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 7: Train Decision Tree Classifier
model = DecisionTreeClassifier(criterion="gini", random_state=42)
model.fit(X_train, y_train)

# Step 8: Visualize Decision Tree
plt.figure(figsize=(14, 8))
plot_tree(
    model,
    feature_names=X.columns,
    class_names=["Rejected", "Approved"],
    filled=True
)
plt.title("Loan Approval Decision Tree")
plt.show()


plt.figure(figsize=(15, 8))
plot_tree(model, feature_names=X.columns, filled=True)
plt.show()


# Step 9: Predict Test Records
y_pred = model.predict(X_test)

print("\nActual Values:", y_test.tolist())
print("Predicted Values:", y_pred.tolist())

# Step 10: Evaluate Model
print("\nAccuracy:", accuracy_score(y_test, y_pred))
print("Precision:", precision_score(y_test, y_pred, zero_division=0))
print("Recall:", recall_score(y_test, y_pred, zero_division=0))
print("F1-Score:", f1_score(y_test, y_pred, zero_division=0))

print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(
    y_test, y_pred, zero_division=0
))

# Conclusion
print("Decision Tree predicts loan approval using applicant information.")







#Q15 Customer Churn Prediction Using Decision Tree

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix, precision_score
from sklearn.metrics import recall_score, f1_score, classification_report

# Step 2: Load Dataset
df = pd.read_csv("customer_churn.csv")

print("First Five Records:")
print(df.head())

print("\nDataset Shape:", df.shape)
print("\nDataset Information:")
print(df.info())

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

print("\nStatistical Summary:")
print(df.describe())

# Step 3: Exploratory Data Analysis (EDA)
print("\nChurn Class Distribution:")
print(df["Churn"].value_counts())

df["Churn"].value_counts().plot(kind="bar")
plt.title("Customer Churn Distribution")
plt.xlabel("Churn")
plt.ylabel("Number of Customers")
plt.show()

# Step 4: Handle Missing Values
for col in df.columns:
    if df[col].dtype == "object":
        df[col] = df[col].fillna(df[col].mode()[0])
    else:
        df[col] = df[col].fillna(df[col].median())

# Remove Customer ID if present
if "customerID" in df.columns:
    df = df.drop("customerID", axis=1)

# Convert TotalCharges to numeric if present
if "TotalCharges" in df.columns:
    df["TotalCharges"] = pd.to_numeric(
        df["TotalCharges"], errors="coerce"
    )
    df["TotalCharges"] = df["TotalCharges"].fillna(
        df["TotalCharges"].median()
    )

# Step 5: Encode Categorical Variables
for col in df.select_dtypes(include="object").columns:
    le = LabelEncoder()
    df[col] = le.fit_transform(df[col])

# Step 6: Prepare Features and Target
X = df.drop("Churn", axis=1)
y = df["Churn"]

# Step 7: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 8: Train Decision Tree Classifier
model = DecisionTreeClassifier(
    criterion="gini", random_state=42
)
model.fit(X_train, y_train)

# Step 9: Predict Churn for Test Dataset
y_pred = model.predict(X_test)

print("\nPredicted Churn Values:")
print(y_pred)

# Step 10: Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("\nConfusion Matrix:\n", cm)

sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.title("Customer Churn Confusion Matrix")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()

# Step 11: Evaluation Metrics
print("Precision:", precision_score(y_test, y_pred, zero_division=0))
print("Recall:", recall_score(y_test, y_pred, zero_division=0))
print("F1-Score:", f1_score(y_test, y_pred, zero_division=0))

print("\nClassification Report:")
print(classification_report(y_test, y_pred, zero_division=0))

# Conclusion
print("Decision Tree classifies customers based on their likelihood of churn.")









# Q16. Disease Classification Using Decision Tree

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, precision_score
from sklearn.metrics import recall_score, f1_score, confusion_matrix
from sklearn.metrics import classification_report

# Step 2: Load Dataset
df = pd.read_csv("breast_cancer.csv")

print("First Five Records:")
print(df.head())

print("\nDataset Shape:", df.shape)
print("\nDataset Information:")
df.info()

# Step 3: Identify Diagnostic Target
print("\nTarget Class Distribution:")
print(df["diagnosis"].value_counts())

# Step 4: Inspect Missing Values
print("\nMissing Values:")
print(df.isnull().sum())

# Remove Unnecessary ID Column if Present
if "id" in df.columns:
    df = df.drop("id", axis=1)

if "Unnamed: 32" in df.columns:
    df = df.drop("Unnamed: 32", axis=1)

# Step 5: Handle Missing Values
for col in df.columns:
    if df[col].dtype == "object":
        df[col] = df[col].fillna(df[col].mode()[0])
    else:
        df[col] = df[col].fillna(df[col].median())

# Step 6: Inspect Feature Distributions
print("\nStatistical Summary:")
print(df.describe())

df["diagnosis"].value_counts().plot(kind="bar")
plt.title("Disease Class Distribution")
plt.xlabel("Diagnosis (B = Benign, M = Malignant)")
plt.ylabel("Number of Records")
plt.show()

# Step 7: Prepare Features and Target
X = df.drop("diagnosis", axis=1)
y = LabelEncoder().fit_transform(df["diagnosis"])

# Step 8: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 9: Train Decision Tree Classifier
model = DecisionTreeClassifier(
    criterion="gini", random_state=42
)
model.fit(X_train, y_train)

# Step 10: Predict Unseen Test Records
y_pred = model.predict(X_test)

print("\nPredicted Classes:")
print(y_pred)

# Step 11: Evaluate Model
print("\nAccuracy:", accuracy_score(y_test, y_pred))
print("Precision:", precision_score(y_test, y_pred, zero_division=0))
print("Recall:", recall_score(y_test, y_pred, zero_division=0))
print("F1-Score:", f1_score(y_test, y_pred, zero_division=0))

# Step 12: Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("\nConfusion Matrix:\n", cm)

sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.title("Disease Classification Confusion Matrix")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()

print("\nClassification Report:")
print(classification_report(y_test, y_pred, zero_division=0))

# Conclusion
print("Decision Tree classifies medical records using diagnostic features.")


# Q17. Decision Tree Optimization Using Entropy and Gini

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score, classification_report

# Step 2: Load Dataset
df = pd.read_csv("classification_data.csv")

print("First Five Records:")
print(df.head())

print("\nDataset Shape:", df.shape)
print("\nMissing Values:\n", df.isnull().sum())

# Step 3: Handle Missing Values
for col in df.columns:
    if df[col].dtype == "object":
        df[col] = df[col].fillna(df[col].mode()[0])
    else:
        df[col] = df[col].fillna(df[col].median())

df = df.drop_duplicates()

# Step 4: Select Target and Features
# Change "target" to the actual target column name in your CSV
target = "target"

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

# Encode Categorical Features
X = pd.get_dummies(X, drop_first=True)

# Encode Target if Categorical
if y.dtype == "object":
    y = LabelEncoder().fit_transform(y)

# Step 5: Fixed Train-Test Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Step 6: Train Decision Tree Using Gini
gini_model = DecisionTreeClassifier(
    criterion="gini", random_state=42
)
gini_model.fit(X_train, y_train)
gini_pred = gini_model.predict(X_test)

print("\n--- GINI MODEL ---")
print("Accuracy:", accuracy_score(y_test, gini_pred))
print(classification_report(y_test, gini_pred, zero_division=0))

# Step 7: Train Decision Tree Using Entropy
entropy_model = DecisionTreeClassifier(
    criterion="entropy", random_state=42
)
entropy_model.fit(X_train, y_train)
entropy_pred = entropy_model.predict(X_test)

print("\n--- ENTROPY MODEL ---")
print("Accuracy:", accuracy_score(y_test, entropy_pred))
print(classification_report(y_test, entropy_pred, zero_division=0))

# Step 8: Compare Tree Structures
print("\nGini Tree Depth:", gini_model.get_depth())
print("Gini Number of Leaves:", gini_model.get_n_leaves())

print("\nEntropy Tree Depth:", entropy_model.get_depth())
print("Entropy Number of Leaves:", entropy_model.get_n_leaves())

# Visualize Gini Tree
plt.figure(figsize=(14, 7))
plot_tree(gini_model, feature_names=X.columns, filled=True)
plt.title("Decision Tree - Gini")
plt.show()

# Visualize Entropy Tree
plt.figure(figsize=(14, 7))
plot_tree(entropy_model, feature_names=X.columns, filled=True)
plt.title("Decision Tree - Entropy")
plt.show()

# Step 9: Hyperparameter Tuning Using Cross-Validation
grid = GridSearchCV(DecisionTreeClassifier(), {
    'max_depth': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}, cv=5)

grid.fit(X_train, y_train)

print(grid.best_params_)
print(grid.best_score_)

# Step 10: Evaluate Tuned Model on Test Data
best_model = grid.best_estimator_
best_pred = best_model.predict(X_test)
print("\n--- TUNED MODEL ---")
print("Test Accuracy:", accuracy_score(y_test, best_pred))
print(classification_report(y_test, best_pred, zero_division=0))

# Conclusion
print("Gini, Entropy and tuned Decision Trees have been compared.")







# Q18. Iris Flower Classification Using KNN

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Step 2: Load Dataset
df = pd.read_csv("Iris.csv")

print("First Five Records:")
print(df.head())

print("\nDataset Shape:", df.shape)
print("\nMissing Values:\n", df.isnull().sum())

# Step 3: Separate Features and Target
# Drop Id column if present
if "Id" in df.columns:
    df = df.drop("Id", axis=1)

# Identify the species column
target = "Species"

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

# Encode Species Labels
le = LabelEncoder()
y = le.fit_transform(y)

print("\nFeatures:")
print(X.head())

print("\nSpecies Classes:", le.classes_)

# Step 4: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 5: Standardize Features
scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Step 6: Train KNN Using Different K Values
k_values = [3, 5, 7]
accuracies = []

for k in k_values:
    model = KNeighborsClassifier(n_neighbors=k)
    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)

    accuracies.append(accuracy)

    print("\nK =", k)
    print("Test Accuracy:", accuracy)

# Step 7: Select Best K
best_index = accuracies.index(max(accuracies))
best_k = k_values[best_index]

print("\nBest K Value:", best_k)
print("Best Test Accuracy:", max(accuracies))

# Step 8: Visualize Accuracy Comparison
plt.plot(k_values, accuracies, marker="o")
plt.xlabel("K Value")
plt.ylabel("Test Accuracy")
plt.title("KNN Accuracy Comparison")
plt.xticks(k_values)
plt.grid(True)
plt.show()

# Conclusion
print("KNN classifies Iris flowers using the nearest neighbors.")



# Q19. Student Performance Classification Using KNN
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix
Load Dataset
df = pd.read_csv("student_performance.csv")
Features and Target
X = df[["Attendance", "StudyHours", "InternalMarks"]]
y = df["Performance"]
X = X.fillna(X.median())
y = y.fillna(y.mode()[0])
le = LabelEncoder()
y = le.fit_transform(y)
Split and Scale Data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Test Different K Values
for k in [3, 5, 7]:
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X_train, y_train)
pred = model.predict(X_test)
print("\nK =", k)
print("Accuracy:", accuracy_score(y_test, pred))
print("Precision:", precision_score(y_test, pred, average="weighted", zero_division=0))
print("Recall:", recall_score(y_test, pred, average="weighted", zero_division=0))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
Predict New Student Using K = 5
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
student = [[
float(input("Attendance: ")),
float(input("Study Hours: ")),
float(input("Internal Marks: "))
]]
student = scaler.transform(student)
print("Predicted Performance:", le.inverse_transform(model.predict(student))[0])



# Q20. Diabetes Classification Using KNN
KNN Diabetes Classification
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix
Load Dataset
df = pd.read_csv("diabetes.csv")
print(df.head())
print(df.isnull().sum())
Handle Invalid Zeros
cols = ["Glucose", "BloodPressure", "SkinThickness", "Insulin", "BMI"]
df[cols] = df[cols].replace(0, float("nan"))
df[cols] = df[cols].fillna(df[cols].median())
Features and Target
X = df.drop("Outcome", axis=1)
y = df["Outcome"]
Split Data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
Standardize Features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Train and Compare KNN
for k in [3, 5, 7]:
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X_train, y_train)
pred = model.predict(X_test)
print("\nK =", k)
print("Precision:", precision_score(y_test, pred, zero_division=0))
print("Recall:", recall_score(y_test, pred, zero_division=0))
print("F1-Score:", f1_score(y_test, pred, zero_division=0))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
print("KNN diabetes classification completed.")



# Q21. Spam Detection Using Naive Bayes
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report, confusion_matrix

Load Dataset
df = pd.read_csv("spam.csv", encoding="latin-1")
df.columns = ["label", "message"]
Split Data
X_train, X_test, y_train, y_test = train_test_split(
df["message"], df["label"], test_size=0.2, random_state=42
)
Convert Text into Numbers
tfidf = TfidfVectorizer()
X_train = tfidf.fit_transform(X_train)
X_test = tfidf.transform(X_test)
Train Model
model = MultinomialNB()
model.fit(X_train, y_train)
Predict
pred = model.predict(X_test)
Evaluation
print("Classification Report:\n", classification_report(y_test, pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
Test a New Message
print("Prediction:", model.predict(
tfidf.transform(["Congratulations! You won a free prize"])
)[0])

# Q22. Iris Classification Using Gaussian Naive Bayes

Gaussian Naive Bayes vs Decision Tree
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
Load Dataset
iris = load_iris()
X = iris.data
y = iris.target
Split Data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
Train Models
nb = GaussianNB()
dt = DecisionTreeClassifier(random_state=42)
nb.fit(X_train, y_train)
dt.fit(X_train, y_train)
Predictions
nb_pred = nb.predict(X_test)
dt_pred = dt.predict(X_test)
Evaluate Models
for name, pred in [("Naive Bayes", nb_pred), ("Decision Tree", dt_pred)]:
print("\n", name)
print("Accuracy:", accuracy_score(y_test, pred))
print(classification_report(y_test, pred, zero_division=0))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
Independence Assumption
print("Naive Bayes assumes features are conditionally independent given the class.")


# Q23. Compare Random Forest and Decision Tree

# Step 1: Import Libraries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score
from sklearn.preprocessing import LabelEncoder

# Step 2: Load Dataset
df = pd.read_csv("Iris.csv")
print("First Five Records:")
print(df.head())

# Step 3: Preprocess the Data
if "Id" in df.columns:
    df = df.drop("Id", axis=1)

X = df.drop("Species", axis=1)
y = df["Species"]

# Convert target labels into numbers if required
encoder = LabelEncoder()
y = encoder.fit_transform(y)

# Step 4: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 5: Train Decision Tree
dt_model = DecisionTreeClassifier(random_state=42)
dt_model.fit(X_train, y_train)
dt_pred = dt_model.predict(X_test)

# Step 6: Train Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
rf_pred = rf_model.predict(X_test)

# Step 7: Evaluate and Compare Models
for name, pred in [
    ("Decision Tree", dt_pred),
    ("Random Forest", rf_pred)
]:
    print("\n", name)
    print("Accuracy:", accuracy_score(y_test, pred))
    print("Precision:", precision_score(
        y_test, pred, average="weighted", zero_division=0
    ))
    print("Recall:", recall_score(
        y_test, pred, average="weighted", zero_division=0
    ))
    print("F1-Score:", f1_score(
        y_test, pred, average="weighted", zero_division=0
    ))

# Step 8: Conclusion
print("\nBoth models have been evaluated on the same test data.")


# Q24. Titanic Survival Prediction Using Random Forest

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score
from sklearn.metrics import f1_score, confusion_matrix, classification_report

# Step 2: Load Dataset
df = pd.read_csv("Titanic.csv")

print("First Five Records:")
print(df.head())

# Step 3: Select Relevant Features
X = df[["Pclass", "Sex", "Age", "Fare"]]
y = df["Survived"]

# Step 4: Handle Missing Values
X = X.copy()
X["Age"] = X["Age"].fillna(X["Age"].median())
X["Fare"] = X["Fare"].fillna(X["Fare"].median())
X["Sex"] = X["Sex"].fillna(X["Sex"].mode()[0])

# Step 5: Encode Categorical Variable
X["Sex"] = X["Sex"].map({"male": 0, "female": 1})

# Step 6: Split Dataset
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 7: Train Random Forest Model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Step 8: Make Predictions
y_pred = model.predict(X_test)

# Step 9: Evaluate Model
print("\nAccuracy:", accuracy_score(y_test, y_pred))
print("Precision:", precision_score(y_test, y_pred, zero_division=0))
print("Recall:", recall_score(y_test, y_pred, zero_division=0))
print("F1-Score:", f1_score(y_test, y_pred, zero_division=0))

print("\nClassification Report:")
print(classification_report(y_test, y_pred, zero_division=0))

# Step 10: Display Confusion Matrix
cm = confusion_matrix(y_test, y_pred)

sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Titanic Survival - Confusion Matrix")
plt.show()

# Step 11: Conclusion
print("Titanic survival prediction completed using Random Forest.")










# Q25. Customer Clustering Using K-Means

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Step 2: Load Dataset
df = pd.read_csv("Mall_Customers.csv")
print("First Five Records:")
print(df.head())

# Step 3: Select Features
X = df[["Annual Income (k$)", "Spending Score (1-100)"]]

# Step 4: Inspect Data
print("\nMissing Values:")
print(X.isnull().sum())

print("\nFeature Distribution:")
print(X.describe())

# Handle Missing Values
X = X.fillna(X.median())

# Step 5: Scale Features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 6: Elbow Method
inertia = []

for k in range(1, 11):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertia.append(model.inertia_)

plt.plot(range(1, 11), inertia, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Inertia")
plt.title("Elbow Method")
plt.show()

# Step 7: Apply K-Means
# K=5 is commonly used for the Mall Customers dataset.
kmeans = KMeans(n_clusters=5, random_state=42, n_init=10)
df["Cluster"] = kmeans.fit_predict(X_scaled)

# Convert Centroids Back to Original Scale
centroids = scaler.inverse_transform(kmeans.cluster_centers_)

# Step 8: Plot Clusters and Centroids
plt.figure(figsize=(8, 5))

sns.scatterplot(
    x=X["Annual Income (k$)"],
    y=X["Spending Score (1-100)"],
    hue=df["Cluster"],
    palette="Set1",
    s=70
)

plt.scatter(
    centroids[:, 0],
    centroids[:, 1],
    marker="X",
    s=250,
    color="black",
    label="Centroids"
)

plt.xlabel("Annual Income (k$)")
plt.ylabel("Spending Score (1-100)")
plt.title("Customer Segmentation Using K-Means")
plt.legend()
plt.show()

# Step 9: Describe Customer Segments
print("\nCustomer Segment Characteristics:")
print(
    df.groupby("Cluster")[
        ["Annual Income (k$)", "Spending Score (1-100)"]
    ].mean().round(2)
)

print("\nNumber of Customers in Each Cluster:")
print(df["Cluster"].value_counts().sort_index())

# Step 10: Conclusion
print("\nCustomer segmentation completed using K-Means.")








K means

# Step 1: Import libraries
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Step 2: Load dataset
df = pd.read_csv("Mall_Customers.csv")

print(df.head())
print(df.dtypes)
print(df.isnull().sum())

# Step 3: Select numerical features manually
# Change these columns according to the question
X = df[['Annual Income (k$)', 'Spending Score (1-100)']]

# For Q26, use:
# X = df[['Attendance', 'InternalMarks', 'AssignmentScore']]

# For Q28, select at least 3 numerical features.

# Step 4: Handle missing values
X = X.fillna(X.mean())

# Step 5: Standardize features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 6: Elbow method
inertia = []

for k in range(1, 8):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertia.append(model.inertia_)

plt.plot(range(1, 8), inertia, marker='o')
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Inertia")
plt.title("Elbow Method")
plt.show()

# Step 7: Fit final K-Means model
k = 5
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
df['Cluster'] = kmeans.fit_predict(X_scaled)

# Step 8: Print cluster assignments
print("\nData with cluster labels:")
print(df[['Cluster']].head())

# Step 9: Number of customers/students in each cluster
print("\nNumber of records in each cluster:")
print(df['Cluster'].value_counts().sort_index())

# Step 10: Print cluster centers
print("\nCluster centers (scaled values):")
print(kmeans.cluster_centers_)

# Step 11: Visualize clusters and centroids
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=df['Cluster'])
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
            color='black', marker='X')
plt.show()


plt.xlabel(X.columns[0])
plt.ylabel(X.columns[1])
plt.title("K-Means Clustering")
plt.legend()
plt.show()

# Step 12: Describe cluster profiles
print(df.groupby('Cluster')[X.columns.tolist()].mean())

























# Q26. Student Grouping Using K-Means

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Step 2: Load Dataset
df = pd.read_csv("student_performance.csv")
print("First Five Records:")
print(df.head())

# Step 3: Select Three Academic Features
features = ["Attendance", "InternalMarks", "AssignmentScore"]
X = df[features].copy()

# Step 4: Check Missing Values
print("\nMissing Values:")
print(X.isnull().sum())

X = X.fillna(X.median())

# Step 5: Standardize Features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 6: Elbow Method
inertia = []

for k in range(1, 11):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertia.append(model.inertia_)

plt.plot(range(1, 11), inertia, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Inertia")
plt.title("Elbow Method for Student Grouping")
plt.show()

# Step 7: Train K-Means
# Choose K after inspecting the elbow graph.
k = 3
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
df["Cluster"] = kmeans.fit_predict(X_scaled)

# Step 8: Reduce Features to 2D Using PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)

plt.figure(figsize=(8, 5))
plt.scatter(
    X_2d[:, 0],
    X_2d[:, 1],
    c=df["Cluster"],
    cmap="viridis",
    s=60
)
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("Student Clusters Using PCA")
plt.colorbar(label="Cluster")
plt.show()

# Step 9: Interpret Cluster Profiles
print("\nAverage Academic Features in Each Cluster:")
print(df.groupby("Cluster")[features].mean().round(2))

print("\nNumber of Students in Each Cluster:")
print(df["Cluster"].value_counts().sort_index())

# Step 10: Conclusion
print("\nStudent grouping completed using K-Means.")
print("Clusters show patterns in the selected data, not fixed measures of ability.")











# Q27. Mall Customer Clustering Using K-Means

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Step 2: Load Dataset
df = pd.read_csv("Mall_Customers.csv")
print("First Five Records:")
print(df.head())

# Step 3: Select Features
X = df[["Annual Income (k$)", "Spending Score (1-100)"]].copy()

# Step 4: Check Missing Values
print("\nMissing Values:")
print(X.isnull().sum())

X = X.fillna(X.median())

# Step 5: Standardize Features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 6: Elbow Method
inertia = []

for k in range(1, 11):
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    model.fit(X_scaled)
    inertia.append(model.inertia_)

plt.plot(range(1, 11), inertia, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Inertia")
plt.title("Elbow Method")
plt.show()

# Step 7: Fit K-Means
# K=5 is commonly used for this dataset; verify using the elbow graph.
k = 5
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
df["Cluster"] = kmeans.fit_predict(X_scaled)

# Step 8: Convert Centroids to Original Scale
centroids = scaler.inverse_transform(kmeans.cluster_centers_)

# Step 9: Plot Clusters and Centroids
plt.figure(figsize=(8, 5))

plt.scatter(
    X["Annual Income (k$)"],
    X["Spending Score (1-100)"],
    c=df["Cluster"],
    cmap="viridis",
    s=60
)

plt.scatter(
    centroids[:, 0],
    centroids[:, 1],
    color="red",
    marker="X",
    s=250,
    label="Centroids"
)

plt.xlabel("Annual Income (k$)")
plt.ylabel("Spending Score (1-100)")
plt.title("Mall Customer Clusters")
plt.legend()
plt.show()

# Step 10: Count Customers in Each Cluster
print("\nNumber of Customers in Each Cluster:")
print(df["Cluster"].value_counts().sort_index())

# Step 11: Display Cluster Profiles
print("\nAverage Income and Spending Score:")
print(
    df.groupby("Cluster")[
        ["Annual Income (k$)", "Spending Score (1-100)"]
    ].mean().round(2)
)
# Step 12: Conclusion
print("\nMall customer clustering completed using K-Means.")

# Q28. Evaluate K-Means Clustering

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.metrics import silhouette_score

# Step 2: Load Numerical Dataset
df = pd.read_csv("numerical_data.csv")
print("First Five Records:")
print(df.head())

# Step 3: Select Numerical Features
X = df.select_dtypes(include="number").copy()

# Remove ID columns if present
X = X.drop(
    columns=["ID", "CustomerID", "StudentID"],
    errors="ignore"
)
# Step 4: Handle Missing Values
X = X.fillna(X.median())

# Step 5: Standardize Features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 6: Evaluate Different Values of K
inertia = []
silhouette = []
k_values = [2, 3, 4, 5, 6]

for k in k_values:
    model = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = model.fit_predict(X_scaled)

    inertia.append(model.inertia_)
    silhouette.append(silhouette_score(X_scaled, labels))
# Display Evaluation Results
results = pd.DataFrame({
    "K": k_values,
    "Inertia": inertia,
    "Silhouette Score": silhouette
})

print("\nEvaluation Results:")
print(results.round(3))

# Step 7: Plot Elbow Method
plt.plot(k_values, inertia, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Inertia")
plt.title("Elbow Method")
plt.show()

# Step 8: Plot Silhouette Scores
plt.plot(k_values, silhouette, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Silhouette Score")
plt.title("Silhouette Score for Different K")
plt.show()

# Step 9: Select K with Highest Silhouette Score
best_k = k_values[silhouette.index(max(silhouette))]
print("\nSelected K:", best_k)

# Step 10: Train Final K-Means Model
final_model = KMeans(
    n_clusters=best_k, random_state=42, n_init=10
)
df["Cluster"] = final_model.fit_predict(X_scaled)

# Step 11: Visualize Final Clusters Using PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)

plt.figure(figsize=(8, 5))
plt.scatter(
    X_2d[:, 0], X_2d[:, 1],
    c=df["Cluster"], cmap="viridis", s=60
)
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("Final K-Means Clusters")
plt.colorbar(label="Cluster")
plt.show()

# Step 12: Interpret Clusters
df["Cluster"] = df["Cluster"].astype(int)

print("\nNumber of Records in Each Cluster:")
print(df["Cluster"].value_counts().sort_index())

print("\nAverage Feature Values in Each Cluster:")
print(df.groupby("Cluster")[X.columns].mean().round(2))

# Step 13: Conclusion
print("\nK-Means evaluation and clustering completed.")
# Q29. Market Basket Analysis Using Apriori

import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules

# OPTION A: Load Dataset from CSV
# data = pd.read_csv("transactions.csv")
# transactions = data.apply(lambda row: row.dropna().tolist(), axis=1).tolist()

# OPTION B: Create Dataset Yourself
transactions = [
    ['Milk', 'Bread', 'Butter'],
    ['Bread', 'Butter'],
    ['Milk', 'Bread'],
    ['Milk', 'Butter'],
    ['Bread', 'Butter', 'Eggs'],
    ['Milk', 'Bread', 'Butter'],
    ['Bread', 'Eggs'],
    ['Milk', 'Bread', 'Eggs'],
    ['Milk', 'Butter'],
    ['Milk', 'Bread', 'Butter']
]

print("Total Transactions:", len(transactions))

te = TransactionEncoder()
encoded_data = te.fit_transform(transactions)
df = pd.DataFrame(encoded_data, columns=te.columns_)

print("\nOne-Hot Encoded Dataset:")
print(df)

frequent_items = apriori(df, min_support=0.2, use_colnames=True)

print("\nFrequent Itemsets:")
print(frequent_items)

rules = association_rules(
    frequent_items, metric="confidence", min_threshold=0.5
)

print("\nAssociation Rules:")
if rules.empty:
    print("No association rules found.")
else:
    print(rules[['antecedents', 'consequents', 'support',
                 'confidence', 'lift']].round(3))

print("\nMarket Basket Analysis Completed.")

















# Q30. Bank Customer Churn Prediction Using ANN

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

data = pd.read_csv("Churn_Modelling.csv")

X = data.drop(['RowNumber', 'CustomerId', 'Surname', 'Exited'], axis=1)
y = data['Exited']

X = pd.get_dummies(X, dtype=int)

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

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

model = Sequential([
    Dense(16, activation='relu', input_shape=(X_train.shape[1],)),
    Dense(8, activation='relu'),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(X_train, y_train, epochs=10, verbose=0)

pred = (model.predict(X_test) >= 0.5).astype(int)

print("Accuracy:", accuracy_score(y_test, pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))




# Q31. Student Pass/Fail Prediction Using ANN

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

data = pd.read_csv("student.csv")

X = data[['StudyHours', 'Attendance', 'PreviousMarks']]
y = data['Pass']

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

sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

model = Sequential([
    Dense(8, activation='relu', input_shape=(3,)),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(X_train, y_train, epochs=10, verbose=0)

pred = (model.predict(X_test) >= 0.5).astype(int)

print("Accuracy:", accuracy_score(y_test, pred))
print("Precision:", precision_score(y_test, pred, zero_division=0))
print("Recall:", recall_score(y_test, pred, zero_division=0))
print("Confusion Matrix:\n", confusion_matrix(y_test, pred))





# Q32. Compare Decision Tree, KNN and Naive Bayes

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, confusion_matrix
)

# Step 2: Load Dataset
df = pd.read_csv("Iris.csv")
print("First Five Records:")
print(df.head())

# Step 3: Handle Missing Values and Select Features
if "Id" in df.columns:
    df = df.drop("Id", axis=1)

X = df.drop("Species", axis=1).copy()
y = df["Species"].copy()

# Fill Missing Numerical Values
X = X.fillna(X.median())

# Step 4: Common Stratified Train-Test Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 5: Scale Features for KNN
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Step 6: Train Three Classifiers
models = {
    "Decision Tree": DecisionTreeClassifier(random_state=42),
    "KNN": KNeighborsClassifier(n_neighbors=5),
    "Naive Bayes": GaussianNB()
}

results = []
predictions = {}

for name, model in models.items():

    # KNN uses scaled features
    if name == "KNN":
        model.fit(X_train_scaled, y_train)
        y_pred = model.predict(X_test_scaled)
    else:
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)

    predictions[name] = y_pred

    results.append({
        "Model": name,
        "Accuracy": accuracy_score(y_test, y_pred),
        "Precision": precision_score(
            y_test, y_pred, average="weighted", zero_division=0
        ),
        "Recall": recall_score(
            y_test, y_pred, average="weighted", zero_division=0
        ),
        "F1-Score": f1_score(
            y_test, y_pred, average="weighted", zero_division=0
        )
    })

# Step 7: Display Comparison Table
comparison = pd.DataFrame(results)
print("\nModel Comparison:")
print(comparison.round(3).to_string(index=False))

# Step 8: Display Confusion Matrices
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

for ax, name in zip(axes, models.keys()):
    cm = confusion_matrix(y_test, predictions[name], labels=models[name].classes_)

    sns.heatmap(
        cm, annot=True, fmt="d", cmap="Blues",
        xticklabels=models[name].classes_,
        yticklabels=models[name].classes_,
        ax=ax
    )

    ax.set_title(name)
    ax.set_xlabel("Predicted")
    ax.set_ylabel("Actual")

plt.tight_layout()
plt.show()

# Step 9: Recommend Model Based on F1-Score
best_model = comparison.loc[comparison["F1-Score"].idxmax()]

print("\nRecommended Model:", best_model["Model"])
print("Accuracy:", round(best_model["Accuracy"], 3))
print("F1-Score:", round(best_model["F1-Score"], 3))

# Step 10: Conclusion
print("\nComparison of all three classifiers completed.")




















# Q33. End-to-End Machine Learning Pipeline
# Dataset: Breast Cancer Classification

# Step 1: Import Libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score,
    f1_score, confusion_matrix, classification_report
)

# Step 2: Load Dataset
df = pd.read_csv("breast_cancer.csv")

print("First Five Records:")
print(df.head())

print("\nDataset Shape:", df.shape)
print("\nData Types:")
print(df.dtypes)

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

print("\nSummary Statistics:")
print(df.describe(include="all"))

# Step 3: Define Target and Features
# Change "diagnosis" if your target column has a different name.
target = "diagnosis"

# Remove common ID columns if present
df = df.drop(columns=["id", "ID", "Unnamed: 32"], errors="ignore")

X = df.drop(columns=[target])
y = df[target]

# Encode target labels if they are text
if y.dtype == "object":
    y = LabelEncoder().fit_transform(y)

# Step 4: Identify Numerical and Categorical Features
numeric_features = X.select_dtypes(include="number").columns.tolist()
categorical_features = X.select_dtypes(exclude="number").columns.tolist()

print("\nNumerical Features:", numeric_features)
print("Categorical Features:", categorical_features)

# Step 5: Split Dataset Before Preprocessing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Step 6: Preprocessing Pipelines
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore"))
])

preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, numeric_features),
    ("cat", categorical_pipeline, categorical_features)
])

# Step 7: Create Complete ML Pipeline
pipeline = Pipeline([
    ("preprocessing", preprocessor),
    ("model", RandomForestClassifier(random_state=42))
])

# Step 8: Hyperparameter Tuning Using Cross-Validation
parameters = {
    "model__n_estimators": [100, 200],
    "model__max_depth": [None, 5, 10],
    "model__min_samples_split": [2, 5]
}

grid_search = GridSearchCV(
    pipeline,
    parameters,
    cv=5,
    scoring="f1_weighted",
    n_jobs=-1
)

grid_search.fit(X_train, y_train)

print("\nBest Parameters:")
print(grid_search.best_params_)

print("Best Cross-Validation F1-Score:", grid_search.best_score_)

# Step 9: Evaluate Final Model on Test Data
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)

print("\nTest Accuracy:", accuracy_score(y_test, y_pred))
print("Test Precision:", precision_score(
    y_test, y_pred, average="weighted", zero_division=0
))
print("Test Recall:", recall_score(
    y_test, y_pred, average="weighted", zero_division=0
))
print("Test F1-Score:", f1_score(
    y_test, y_pred, average="weighted", zero_division=0
))

print("\nClassification Report:")
print(classification_report(y_test, y_pred, zero_division=0))

# Step 10: Confusion Matrix
cm = confusion_matrix(y_test, y_pred)

sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Breast Cancer Classification - Confusion Matrix")
plt.show()

# Step 11: Conclusion
print("\nEnd-to-end machine learning pipeline completed.")














Nqueens

n = int(input("Enter N: "))
b = [-1] * n

def solve(r):
    if r == n:
        return True

    for c in range(n):
        if all(b[i] != c and abs(b[i] - c) != abs(i - r)
               for i in range(r)):
            b[r] = c

            if solve(r + 1):
                return True

    return False
if n >= 4:
    if solve(0):
        for r in range(n):
            for c in range(n):
                if b[r] == c:
                    print("Q", end=" ")
                else:
                    print(".", end=" ")
            print()
    else:
        print("No solution")
else:
    print("No solution")













Sudoku
board = []
print("Enter Sudoku (0 for empty cells):")

for i in range(9):
    row = []
    for j in range(9):
        n = int(input("Enter number: "))
        row.append(n)
    board.append(row)

def solve():
    for r in range(9):
        for c in range(9):
            if board[r][c] == 0:
                for n in range(1, 10):
                    box = []

                    for i in range(3):
                        for j in range(3):
                            box.append(board[r//3*3+i][c//3*3+j])

                    if n not in board[r] and n not in box:
                        if all(board[i][c] != n for i in range(9)):
                            board[r][c] = n

                            if solve():
                                return True

                            board[r][c] = 0

                return False

    return True
if solve():
    print("Solved Sudoku:")

    for i in range(9):
        for j in range(9):
            print(board[i][j], end=" ")
        print()
else:
    print("No solution")

q1
n = int(input("Enter number of cities (at least 8): "))
graph = {}
h = {}

for i in range(n):
    city = input("Enter city name: ")
    h[city] = int(input("Enter heuristic: "))
    graph[city] = {}

for i in range(int(input("Enter number of roads: "))):
    a, b, cost = input("Enter city1 city2 distance: ").split()
    graph[a][b] = int(cost)
    graph[b][a] = int(cost)

start = input("Enter source: ")
goal = input("Enter destination: ")

q = [(h[start], 0, start, [start])]
visited = []

while q:
    q.sort()
    f, g, city, path = q.pop(0)

    if city == goal:
        print("Route:", path)
        print("Total cost:", g)
        print("Nodes explored:", len(visited))
        break

    if city in visited:
        continue
    visited.append(city)

    for next_city, cost in graph[city].items():
        if next_city not in visited:
            ng = g + cost
            q.append((ng + h[next_city], ng, next_city,
                      path + [next_city]))
else:
    print("No route found")


Q2

n = int(input("Enter number of cities (at least 8): "))
graph = {}
h = {}

for i in range(n):
    city = input("Enter city name: ")
    h[city] = int(input("Enter heuristic: "))
    graph[city] = {}

for i in range(int(input("Enter number of roads: "))):
    a, b, cost = input("Enter city1 city2 distance: ").split()
    graph[a][b] = int(cost)
    graph[b][a] = int(cost)

start = input("Enter source: ")
goal = input("Enter destination: ")

q = [(h[start], 0, start, [start])]
visited = []

while q:
    q.sort()
    hv, g, city, path = q.pop(0)

    if city == goal:
        print("Route:", path)
        print("Total cost:", g)
        print("Nodes explored:", len(visited))
        break

    if city in visited:
        continue
    visited.append(city)

    for nxt, cost in graph[city].items():
        if nxt not in visited:
            q.append((h[nxt], g + cost, nxt, path + [nxt]))
else:
    print("No route found")



Q3


n = int(input("Enter grid size (at least 8): "))
sr = int(input("Start row: "))
sc = int(input("Start column: "))
gr = int(input("Goal row: "))
gc = int(input("Goal column: "))

obs = set()
for i in range(int(input("Number of obstacles: "))):
    r = int(input("Obstacle row: "))
    c = int(input("Obstacle column: "))
    obs.add((r, c))

q = [(abs(sr-gr)+abs(sc-gc), 0, sr, sc, [(sr,sc)])]
visited = []

while q:
    q.sort()
    f, g, r, c, path = q.pop(0)

    if (r, c) in visited:
        continue
    visited.append((r, c))

    if (r, c) == (gr, gc):
        print("Path:", path)
        print("Path length:", g)
        print("Cells explored:", len(visited))

        for i in range(n):
            for j in range(n):
                if (i, j) == (sr, sc):
                    print("S", end=" ")
                elif (i, j) == (gr, gc):
                    print("G", end=" ")
                elif (i, j) in obs:
                    print("#", end=" ")
                elif (i, j) in path:
                    print("*", end=" ")
                else:
                    print(".", end=" ")
            print()
        break

    for nr, nc in [(r-1,c), (r+1,c), (r,c-1), (r,c+1)]:
        if 0 <= nr < n and 0 <= nc < n:
            if (nr,nc) not in obs and (nr,nc) not in visited:
               ng = g + 1
                h = abs(nr-gr) + abs(nc-gc)
                q.append((ng+h, ng, nr, nc, path+[(nr,nc)]))
else:
    print("No path found")







