from google.

colab import files

uploaded = files.upload()

Choose Files No file chosen Upload widget is only available when the cell has been executed in the current
browser session. Please rerun this cell to enable.
Saving cardio_train.txt to cardio_train.txt

df = pd.read_csv('cardio_train.txt', sep=';')

# Display first 5 rows

print(df.head())

# Dataset info
print(df.info())

# Check for missing values

print(df.isnull().sum())

id age gender height weight ap_hi ap_lo cholesterol gluc smoke \

0 0 18393 2 168 62.0 110 80 1 1 0
1 1 20228 1 156 85.0 140 90 3 1 0
2 2 18857 1 165 64.0 130 70 3 1 0
3 3 17623 2 169 82.0 150 100 1 1 0
4 4 17474 1 156 56.0 100 60 1 1 0

alco active cardio

0 0 1 0
1 0 1 1
2 0 0 1
3 0 1 1
4 0 0 0
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 70000 entries, 0 to 69999
Data columns (total 13 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 id 70000 non-null int64
1 age 70000 non-null int64
2 gender 70000 non-null int64
3 height 70000 non-null int64
4 weight 70000 non-null float64
5 ap_hi 70000 non-null int64
6 ap_lo 70000 non-null int64
7 cholesterol 70000 non-null int64
8 gluc 70000 non-null int64
9 smoke 70000 non-null int64
10 alco 70000 non-null int64
11 active 70000 non-null int64
12 cardio 70000 non-null int64
dtypes: float64(1), int64(12)
memory usage: 6.9 MB
 None
id 0
age 0
gender 0
height 0
weight 0
ap_hi 0
ap_lo 0
cholesterol 0
gluc 0
smoke 0
alco 0
active 0
cardio 0
dtype: int64

# Summary statistics
print(df.describe())

id age gender height weight \

count 70000.000000 70000.000000 70000.000000 70000.000000 70000.000000
mean 49972.419900 19468.865814 1.349571 164.359229 74.205690
std 28851.302323 2467.251667 0.476838 8.210126 14.395757
min 0.000000 10798.000000 1.000000 55.000000 10.000000
25% 25006.750000 17664.000000 1.000000 159.000000 65.000000
50% 50001.500000 19703.000000 1.000000 165.000000 72.000000
75% 74889.250000 21327.000000 2.000000 170.000000 82.000000
max 99999.000000 23713.000000 2.000000 250.000000 200.000000

ap_hi ap_lo cholesterol gluc smoke \

count 70000.000000 70000.000000 70000.000000 70000.000000 70000.000000
mean 128.817286 96.630414 1.366871 1.226457 0.088129
std 154.011419 188.472530 0.680250 0.572270 0.283484
min -150.000000 -70.000000 1.000000 1.000000 0.000000
25% 120.000000 80.000000 1.000000 1.000000 0.000000
50% 120.000000 80.000000 1.000000 1.000000 0.000000
75% 140.000000 90.000000 2.000000 1.000000 0.000000
max 16020.000000 11000.000000 3.000000 3.000000 1.000000

alco active cardio

count 70000.000000 70000.000000 70000.000000
mean 0.053771 0.803729 0.499700
std 0.225568 0.397179 0.500003
min 0.000000 0.000000 0.000000
25% 0.000000 1.000000 0.000000
50% 0.000000 1.000000 0.000000
75% 0.000000 1.000000 1.000000
max 1.000000 1.000000 1.000000

# Drop 'id' column if it exists

if 'id' in df.columns:
df.drop('id', axis=1, inplace=True)
df['age'] = (df['age'] / 365).astype(int)

import seaborn as sns

import matplotlib.pyplot as plt

# Check if 'cardio' column exists

if 'cardio' in df.columns:
sns.countplot(x='cardio', data=df)
plt.title('Distribution of Cardiovascular Disease')
plt.xlabel('Cardiovascular Disease (0 = No, 1 = Yes)')
plt.ylabel('Count')
plt.show()
else:
print("Column 'cardio' not found.")

# Compute the correlation matrix

correlation_matrix = df.corr()

# Set up the matplotlib figure

plt.figure(figsize=(12, 10))

# Draw the heatmap

sns.heatmap(correlation_matrix, annot=True, fmt=".2f", cmap='coolwarm', square=True)
plt.title('Correlation Heatmap')
plt.show()
from sklearn.model_selection import train_test_split

# Define the features and target

X = df.drop(columns=['cardio']) # Features
y = df['cardio'] # Target

# Split into training and test datasets (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print("Training features shape:", X_train.shape)

print("Test features shape:", X_test.shape)

Training features shape: (56000, 11)

Test features shape: (14000, 11)

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# Initialize and train the model

lr_model = LogisticRegression(max_iter=1000)
lr_model.fit(X_train, y_train)

# Predict on test data

y_pred_lr = lr_model.predict(X_test)

# Evaluate the model

print("Accuracy:", accuracy_score(y_test, y_pred_lr))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_lr))
print("Classification Report:\n", classification_report(y_test, y_pred_lr))

Accuracy: 0.7240714285714286
Confusion Matrix:
[[5360 1628]
[2235 4777]]
Classification Report:
precision recall f1-score support
 0 0.71 0.77 0.74 6988
1 0.75 0.68 0.71 7012

accuracy 0.72 14000

macro avg 0.73 0.72 0.72 14000
weighted avg 0.73 0.72 0.72 14000

/usr/local/lib/python3.11/dist-packages/sklearn/linear_model/_logistic.py:465: Co
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
https://scikit-learn.org/stable/modules/linear_model.html#logistic-regressio
n_iter_i = _check_optimize_result(

import seaborn as sns

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

# Generate the confusion matrix

cm = confusion_matrix(y_test, y_pred_lr)

# Plot the heatmap

plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - Logistic Regression')
plt.show()

from sklearn.svm import SVC

# Initialize and train the model

svm_model = SVC()
svm_model.fit(X_train, y_train)
# Predict on test data
y_pred_svm = svm_model.predict(X_test)

# Evaluate the model

print("SVM Accuracy:", accuracy_score(y_test, y_pred_svm))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_svm))
print("Classification Report:\n", classification_report(y_test, y_pred_svm))

# Visualize confusion matrix

cm_svm = confusion_matrix(y_test, y_pred_svm)
plt.figure(figsize=(6, 4))
sns.heatmap(cm_svm, annot=True, fmt='d', cmap='Oranges')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - SVM')
plt.show()

SVM Accuracy: 0.7228571428571429

Confusion Matrix:
[[5723 1265]
[2615 4397]]
Classification Report:
precision recall f1-score support

0 0.69 0.82 0.75 6988

1 0.78 0.63 0.69 7012

accuracy 0.72 14000

macro avg 0.73 0.72 0.72 14000
weighted avg 0.73 0.72 0.72 14000

from sklearn.neighbors import KNeighborsClassifier

# Initialize and train the model

knn_model = KNeighborsClassifier(n_neighbors=5)
knn_model.fit(X_train, y_train)

# Predict on test data

y_pred_knn = knn_model.predict(X_test)
# Evaluate the model
print("KNN Accuracy:", accuracy_score(y_test, y_pred_knn))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_knn))
print("Classification Report:\n", classification_report(y_test, y_pred_knn))

# Visualize confusion matrix

cm_knn = confusion_matrix(y_test, y_pred_knn)
plt.figure(figsize=(6, 4))
sns.heatmap(cm_knn, annot=True, fmt='d', cmap='Purples')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - KNN')
plt.show()

KNN Accuracy: 0.6846428571428571

Confusion Matrix:
[[4944 2044]
[2371 4641]]
Classification Report:
precision recall f1-score support

0 0.68 0.71 0.69 6988

1 0.69 0.66 0.68 7012

accuracy 0.68 14000

macro avg 0.69 0.68 0.68 14000
weighted avg 0.69 0.68 0.68 14000

from sklearn.tree import DecisionTreeClassifier

# Initialize and train the model

dt_model = DecisionTreeClassifier(random_state=42)
dt_model.fit(X_train, y_train)

# Predict on test data

y_pred_dt = dt_model.predict(X_test)

# Evaluate the model

print("Decision Tree Accuracy:", accuracy_score(y_test, y_pred_dt))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_dt))
print("Classification Report:\n", classification_report(y_test, y_pred_dt))

# Visualize confusion matrix

cm_dt = confusion_matrix(y_test, y_pred_dt)
plt.figure(figsize=(6, 4))
sns.heatmap(cm_dt, annot=True, fmt='d', cmap='Oranges')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - Decision Tree')
plt.show()

Decision Tree Accuracy: 0.6347142857142857

Confusion Matrix:
[[4550 2438]
[2676 4336]]
Classification Report:
precision recall f1-score support

0 0.63 0.65 0.64 6988

1 0.64 0.62 0.63 7012

accuracy 0.63 14000

macro avg 0.63 0.63 0.63 14000
weighted avg 0.63 0.63 0.63 14000

from sklearn.svm import SVC

# Initialize and train the model

svm_model = SVC(kernel='rbf', random_state=42)
svm_model.fit(X_train, y_train)

# Predict on test data

y_pred_svm = svm_model.predict(X_test)

# Evaluate the model

print("SVM Accuracy:", accuracy_score(y_test, y_pred_svm))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_svm))
print("Classification Report:\n", classification_report(y_test, y_pred_svm))

# Visualize confusion matrix

cm_svm = confusion_matrix(y_test, y_pred_svm)
plt.figure(figsize=(6, 4))
sns.heatmap(cm_svm, annot=True, fmt='d', cmap='Purples')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - SVM')
plt.show()

SVM Accuracy: 0.7228571428571429

Confusion Matrix:
[[5723 1265]
[2615 4397]]
Classification Report:
precision recall f1-score support

0 0.69 0.82 0.75 6988

1 0.78 0.63 0.69 7012

accuracy 0.72 14000

macro avg 0.73 0.72 0.72 14000
weighted avg 0.73 0.72 0.72 14000

from sklearn.svm import SVC

# Initialize and train the model

svm_model = SVC()
svm_model.fit(X_train, y_train)

# Predict on test data

y_pred_svm = svm_model.predict(X_test)

# Evaluate the model

print("SVM Accuracy:", accuracy_score(y_test, y_pred_svm))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_svm))
print("Classification Report:\n", classification_report(y_test, y_pred_svm))
 SVM Accuracy: 0.7228571428571429
Confusion Matrix:
[[5723 1265]
[2615 4397]]
Classification Report:
precision recall f1-score support

0 0.69 0.82 0.75 6988

1 0.78 0.63 0.69 7012

accuracy 0.72 14000

macro avg 0.73 0.72 0.72 14000
weighted avg 0.73 0.72 0.72 14000

from sklearn.tree import DecisionTreeClassifier

# Initialize and train the model

dt_model = DecisionTreeClassifier(random_state=42)
dt_model.fit(X_train, y_train)

# Predict on test data

y_pred_dt = dt_model.predict(X_test)

# Evaluate the model

print("Decision Tree Accuracy:", accuracy_score(y_test, y_pred_dt))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_dt))
print("Classification Report:\n", classification_report(y_test, y_pred_dt))

Decision Tree Accuracy: 0.6347142857142857

Confusion Matrix:
[[4550 2438]
[2676 4336]]
Classification Report:
precision recall f1-score support

0 0.63 0.65 0.64 6988

1 0.64 0.62 0.63 7012

accuracy 0.63 14000

macro avg 0.63 0.63 0.63 14000
weighted avg 0.63 0.63 0.63 14000

from sklearn.ensemble import RandomForestClassifier

# Initialize and train the model

rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Predict on test data

y_pred_rf = rf_model.predict(X_test)

# Evaluate the model

print("Random Forest Accuracy:", accuracy_score(y_test, y_pred_rf))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_rf))
print("Classification Report:\n", classification_report(y_test, y_pred_rf))

Random Forest Accuracy: 0.7057142857142857

Confusion Matrix:
[[4947 2041]
[2079 4933]]
Classification Report:
precision recall f1-score support

0 0.70 0.71 0.71 6988

1 0.71 0.70 0.71 7012

accuracy 0.71 14000

macro avg 0.71 0.71 0.71 14000
weighted avg 0.71 0.71 0.71 14000

# Dictionary of model names and their accuracy scores

model_accuracies = {
'Logistic Regression': accuracy_score(y_test, y_pred_lr),
'Decision Tree': accuracy_score(y_test, y_pred_dt),
'Random Forest': accuracy_score(y_test, y_pred_rf),
'SVM': accuracy_score(y_test, y_pred_svm),
'KNN': accuracy_score(y_test, y_pred_knn)
}

# Display model comparison

for model, acc in model_accuracies.items():
print(f'{model}: {acc:.4f}')

Logistic Regression: 0.7241

Decision Tree: 0.6347
Random Forest: 0.7057
SVM: 0.7229
KNN: 0.6846

# Bar plot to visualize accuracies

plt.figure(figsize=(10, 6))
plt.bar(model_accuracies.keys(), model_accuracies.values(), color='skyblue')
plt.ylabel('Accuracy')
plt.title('Model Accuracy Comparison')
plt.xticks(rotation=45)
plt.ylim(0.5, 1)
plt.show()
# Get feature importances from Random Forest model
importances = rf_model.feature_importances_
feature_names = X.columns

# Create a DataFrame for visualization

feature_importance_df = pd.DataFrame({'Feature': feature_names, 'Importance': importances})
feature_importance_df = feature_importance_df.sort_values(by='Importance', ascending=False)

# Display top features

print(feature_importance_df.head(10))

Feature Importance
3 weight 0.230041
2 height 0.211850
4 ap_hi 0.186320
0 age 0.164083
5 ap_lo 0.096743
6 cholesterol 0.040225
1 gender 0.019445
7 gluc 0.018327
10 active 0.015191
8 smoke 0.009663

# Bar plot of feature importance

plt.figure(figsize=(10, 6))
sns.barplot(x='Importance', y='Feature', data=feature_importance_df.head(10), palette='virid
plt.title('Top 10 Important Features - Random Forest')
plt.tight_layout()
plt.show()
 <ipython-input-28-696a840a30af>:3: FutureWarning:

Passing `palette` without assigning `hue` is deprecated and will be removed in v

sns.barplot(x='Importance', y='Feature', data=feature_importance_df.head(10),

import joblib

# Save the model

joblib.dump(rf_model, 'random_forest_cardio_model.pkl')

print("Model saved successfully!")

Model saved successfully!

# Load the model

loaded_model = joblib.load('random_forest_cardio_model.pkl')

# Example prediction
sample_prediction = loaded_model.predict(X_test[:5])
print("Sample predictions:", sample_prediction)

Sample predictions: [1 1 1 0 0]

from sklearn.model_selection import GridSearchCV

param_grid = {
'n_estimators': [100, 200],
'max_depth': [10, 20],
'min_samples_split': [2, 5]
}

grid_search = GridSearchCV(RandomForestClassifier(), param_grid, cv=5, scoring='accuracy')

grid_search.fit(X_train, y_train)

print("Best parameters:", grid_search.best_params_)

print("Best score:", grid_search.best_score_)

Best parameters: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 200}

Best score: 0.7348035714285714
import matplotlib.pyplot as plt
import seaborn as sns

feature_importance = rf_model.feature_importances_
features = X.columns
sorted_idx = feature_importance.argsort()

plt.figure(figsize=(10, 6))
sns.barplot(x=feature_importance[sorted_idx], y=features[sorted_idx])
plt.title("Feature Importance - Random Forest")
plt.show()

predictions = rf_model.predict(X_test)
output = pd.DataFrame({'Actual': y_test, 'Predicted': predictions})
output.to_csv('predictions.csv', index=False)
print("Predictions saved.")

Predictions saved.

from sklearn.model_selection import GridSearchCV

from sklearn.ensemble import RandomForestClassifier

# Define the model

rf = RandomForestClassifier(random_state=42)
...

Ellipsis

from sklearn.model_selection import GridSearchCV

from sklearn.ensemble import RandomForestClassifier

# Define the model

rf = RandomForestClassifier(random_state=42)

# Define parameter grid

param_grid = {
'n_estimators': [100, 200],
'max_depth': [None, 10, 20],
'min_samples_split': [2, 5],
'min_samples_leaf': [1, 2],
}

# Perform Grid Search

grid_search = GridSearchCV(estimator=rf, param_grid=param_grid,
cv=3, n_jobs=-1, verbose=1, scoring='accuracy')

grid_search.fit(X_train, y_train)

# Assign the best estimator to best_rf

best_rf = grid_search.best_estimator_

Fitting 3 folds for each of 24 candidates, totalling 72 fits

from sklearn.metrics import roc_curve, auc

import matplotlib.pyplot as plt

# Predict probabilities
y_proba = best_rf.predict_proba(X_test)[:, 1]

# Compute ROC curve and ROC area

fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

# Plot ROC curve

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_au
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic - Random Forest')
plt.legend(loc="lower right")
plt.grid()
plt.show()

import joblib

# Save the best Random Forest model to a file