#naive bayes
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import (
    accuracy_score, confusion_matrix, precision_score,
    recall_score, roc_curve, auc
)
file_path = r"C:\Users\SARVI\Downloads\heart_disease.csv"
target = "Heart Disease Status"
data = pd.read_csv(file_path)
# Uncomment and adjust only if the dataset has no target column
# data["Result"] = (data["math score"] >= 40).astype(int)
#(if continuous values like 0.65 -) data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
# target = "Result"
if target not in data.columns:
    raise ValueError(f"Target '{target}' not found. Available columns: {data.columns.tolist()}")
data = data.dropna(subset=[target])
X = pd.get_dummies(data.drop(columns=[target]))
X = X.select_dtypes(include="number")
X = X.fillna(X.mean()).fillna(0)
y = data.loc[X.index, target]
y = LabelEncoder().fit_transform(y)
if len(np.unique(y)) != 2:
    raise ValueError("This code requires a binary target with exactly two classes.")
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)
nb_model = GaussianNB()
nb_model.fit(X_train, y_train)
y_pred = nb_model.predict(X_test)
y_pred_prob = nb_model.predict_proba(X_test)[:, 1]
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=[0, 1])
precision = precision_score(y_test, y_pred, zero_division=0)
sensitivity = recall_score(y_test, y_pred, zero_division=0)
TN, FP = conf_matrix[0, 0], conf_matrix[0, 1]
specificity = TN / (TN + FP) if TN + FP else 0
standard_error = np.sqrt(accuracy * (1 - accuracy) / len(y_test))
fpr, tpr, _ = roc_curve(y_test, y_pred_prob)
roc_auc = auc(fpr, tpr)
plt.figure()
plt.plot(fpr, tpr, color="darkorange", lw=2,
         label="ROC curve (area = %0.2f)" % roc_auc)
plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Receiver Operating Characteristic - Naive Bayes")
plt.legend(loc="lower right")
plt.show()
print("Predictions:", y_pred)
print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Standard Error:", standard_error)
print("Precision:", precision)
print("Sensitivity (Recall):", sensitivity)
print("Specificity:", specificity)
print("AUC:", roc_auc)
#decision tree
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import (
    accuracy_score, confusion_matrix, precision_score,
    recall_score, roc_curve, auc
)
file_path = r"C:\Users\SARVI\Downloads\heart_disease.csv"
target = "Heart Disease Status"
data = pd.read_csv(file_path)
# Uncomment and adjust only if the target is missing
#data["Result"] = (data["math score"] >= 40).astype(int)
#(if continuous values like 0.65 -) data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
#target = "Result"
if target not in data.columns:
    raise ValueError(f"Target '{target}' not found. Available columns: {data.columns.tolist()}")
data = data.dropna(subset=[target])
X = pd.get_dummies(data.drop(columns=[target]))
X = X.select_dtypes(include="number").fillna(0)
y = data.loc[X.index, target]
y = LabelEncoder().fit_transform(y)
if len(set(y)) != 2:
    raise ValueError("ROC curve and these metrics require a binary target.")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
dt_model = DecisionTreeClassifier(random_state=42)
dt_model.fit(X_train, y_train)
y_pred = dt_model.predict(X_test)
y_pred_prob = dt_model.predict_proba(X_test)[:, 1]
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=[0, 1])
precision = precision_score(y_test, y_pred, zero_division=0)
sensitivity = recall_score(y_test, y_pred, zero_division=0)
TN, FP = conf_matrix[0, 0], conf_matrix[0, 1]
specificity = TN / (TN + FP) if TN + FP else 0
fpr, tpr, _ = roc_curve(y_test, y_pred_prob)
roc_auc = auc(fpr, tpr)
plt.figure()
plt.plot(fpr, tpr, label="ROC curve (area = %0.2f)" % roc_auc)
plt.plot([0, 1], [0, 1], "--")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve - Decision Tree")
plt.legend(loc="lower right")
plt.show()
plt.figure(figsize=(12, 8))
plot_tree(dt_model, feature_names=X.columns, filled=True)
plt.title("Decision Tree")
plt.show()
print("Predictions:", y_pred)
print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Precision:", precision)
print("Sensitivity (Recall):", sensitivity)
print("Specificity:", specificity)
print("AUC:", roc_auc)
#PCA
import pandas as pd
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import numpy as np
file_path = "diabetes.csv"
target = "Outcome"
data = pd.read_csv(file_path)
# Uncomment and adjust only if the target is missing
# data["Result"] = (data["math score"] >= 40).astype(int)
#(if continuous values like 0.65 -) data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
# target = "Result"
if target not in data.columns:
    raise ValueError(f"Target '{target}' not found. Available columns: {data.columns.tolist()}")
data = data.dropna(subset=[target])
X = pd.get_dummies(data.drop(columns=[target]))
X = X.select_dtypes(include="number").fillna(0)
y = data.loc[X.index, target]
y = LabelEncoder().fit_transform(y)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
n_components = min(7, X_scaled.shape[1], X_scaled.shape[0])
pca = PCA(n_components=n_components)
X_pca = pca.fit_transform(X_scaled)
explained_variance_ratio = pca.explained_variance_ratio_
total_variance_explained = np.sum(explained_variance_ratio)
print("Explained Variance Ratio:", explained_variance_ratio)
print("Total Variance Explained:", total_variance_explained)
plt.figure(figsize=(8, 5))
plt.bar(range(1, n_components + 1), explained_variance_ratio,
        alpha=0.7, align="center",
        label="Individual Explained Variance")
plt.step(range(1, n_components + 1),
         np.cumsum(explained_variance_ratio),
         where="mid", label="Cumulative Explained Variance")
plt.xlabel("Principal Component Index")
plt.ylabel("Explained Variance Ratio")
plt.title("PCA Explained Variance")
plt.legend(loc="best")
plt.show()
X_train, X_test, y_train, y_test = train_test_split(
    X_pca, y, test_size=0.2, random_state=42
)
model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
#linear regression(numeric column)
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
file_path = "diabetes.csv"
target = "Outcome"
data = pd.read_csv(file_path)
# Uncomment and adjust only if the target is missing
# data["Result"] = data["math score"]
#(if continuous values like 0.65 -) data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
# target = "Result"
if target not in data.columns:
    raise ValueError(f"Target '{target}' not found. Available columns: {data.columns.tolist()}")
data = data.dropna(subset=[target])
X = pd.get_dummies(data.drop(columns=[target]))
X = X.select_dtypes(include="number").fillna(0)
y = data.loc[X.index, target]
if not pd.api.types.is_numeric_dtype(y):
    raise ValueError("Linear Regression requires a numeric target column.")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
plt.scatter(y_test, y_pred)
plt.xlabel("Actual Values")
plt.ylabel("Predicted Values")
plt.title("Actual vs Predicted")
plt.show()
residuals = y_test - y_pred
plt.scatter(y_pred, residuals)
plt.axhline(y=0, linestyle="--")
plt.xlabel("Predicted Values")
plt.ylabel("Residuals")
plt.title("Residual Plot")
plt.show()
print("Mean Squared Error:", mse)
print("R2 Score:", r2)
#random forest 
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score,
    confusion_matrix,
    precision_score,
    recall_score,
    classification_report,
    roc_curve,
    auc
)
import matplotlib.pyplot as plt
import numpy as np
data = pd.read_csv("diabetes.csv")
target = "Outcome"
# Convert Yes/No to 1/0; existing 0/1 values remain unchanged
data[target] = data[target].replace({"Yes": 1, "No": 0})
# Uncomment and adjust if you need to create a target
# data["Result"] = (data["math score"] >= 40).astype(int)
#(if continuous values like 0.65 -) data['Outcome'] = data['Outcome'].apply(lambda x: 1 if x >= 0.5 else 0)
# target = "Result"
X = data.drop(columns=[target])
y = data[target]
# Convert categorical input features into numeric columns
X = pd.get_dummies(X)
# Handle missing feature values
X = X.fillna(X.mean()).fillna(0)
# Ensure target is numeric
if not pd.api.types.is_numeric_dtype(y):
    y = pd.factorize(y)[0]
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled,
    y,
    test_size=0.2,
    random_state=42
)
rf_clf = RandomForestClassifier(
    n_estimators=100,
    max_depth=5,
    min_samples_split=2,
    random_state=42,
    n_jobs=-1
)
rf_clf.fit(X_train, y_train)
y_pred_rf = rf_clf.predict(X_test)
y_pred_prob_rf = rf_clf.predict_proba(X_test)[:, 1]
accuracy_rf = accuracy_score(y_test, y_pred_rf)
conf_matrix_rf = confusion_matrix(y_test, y_pred_rf, labels=[0, 1])
precision_rf = precision_score(y_test, y_pred_rf, zero_division=0)
recall_rf = recall_score(y_test, y_pred_rf, zero_division=0)
TN = conf_matrix_rf[0, 0]
FP = conf_matrix_rf[0, 1]
specificity = TN / (TN + FP) if TN + FP else 0
standard_error = np.sqrt(
    accuracy_rf * (1 - accuracy_rf) / len(y_test)
)
fpr_rf, tpr_rf, _ = roc_curve(y_test, y_pred_prob_rf)
roc_auc_rf = auc(fpr_rf, tpr_rf)
print("\nRandom Forest Performance:")
print("Accuracy:", accuracy_rf)
print("Confusion Matrix:\n", conf_matrix_rf)
print("Standard Error:", standard_error)
print("Precision:", precision_rf)
print("Sensitivity (Recall):", recall_rf)
print("Specificity:", specificity)
print("\nClassification Report:\n",
      classification_report(y_test, y_pred_rf, zero_division=0))
plt.figure(figsize=(10, 6))
importances = rf_clf.feature_importances_
sorted_idx = np.argsort(importances)
plt.barh(range(len(sorted_idx)), importances[sorted_idx])
plt.yticks(range(len(sorted_idx)), np.array(X.columns)[sorted_idx])
plt.xlabel("Importance Score")
plt.title("Random Forest Feature Importance")
plt.show()
plt.figure(figsize=(8, 6))
plt.plot(
    fpr_rf, tpr_rf,
    color="darkgreen",
    lw=2,
    label="ROC Curve (AUC = %0.2f)" % roc_auc_rf
)
plt.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Receiver Operating Characteristic - Random Forest")
plt.legend(loc="lower right")
plt.show()
