<jupyter_start><jupyter_text>Diabetes Prediction, using 6 Different ML Algorithms<jupyter_code>import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(color_codes = True)
%matplotlib inline<jupyter_output><empty_output><jupyter_text>Loading and Reviewing the Data<jupyter_code>data_frame = pd.read_csv("diabetes.csv")
data_frame.shape
data_frame.head(5)
data_frame.tail(5)<jupyter_output><empty_output><jupyter_text>Definition of FeaturesFrom Data Source (Kaggle Dataset), we have the following definition of the features.| Feature    |     Description | |--------------|-------------|| 	Pregnancies     | Number of Pregnancies         || Glucose | Plasma glucose concentration a 2 hours in an oral glucose tolerance test         || BloodPressure | Diastolic blood pressure (mm Hg) || SkinThickness | Triceps skin fold thickness (mm) ||Insulin | 2-Hour serum insulin (mu U/ml) || BMI |  Body mass index (weight in kg / (height in m)^2) || DiabetesPedigreeFunction       |  Diabetes pedigree function || Age | Age (years)|| Outcome | Class variable (1 = True, 0 = False) | Here, only "Outcome" is the dependent variable. Every other variable is independent variable.  Checking  for null values<jupyter_code>print (data_frame.isnull().values.any())
data_frame.corr()<jupyter_output><empty_output><jupyter_text>We can see that there are no correlated variables.  Every variable, except "Outcome" is independent.<jupyter_code>corr = data_frame.corr()
mask = np.triu(np.ones_like(corr, dtype = bool))

f, ax = plt.subplots(figsize = (11, 9))

cmap = sns.diverging_palette(210, 20, as_cmap = True)

sns.heatmap(corr, mask = mask, cmap = cmap, vmax = 1, center = 0, square = True, linewidths = .5, cbar_kws = {"shrink": .5})<jupyter_output><empty_output><jupyter_text>The correlations look good.  There appear to be no coorelated columns.  Data TypesInspect data types to see if there are any issues.  The data and its data type(s) look good enough.<jupyter_code>data_frame.head(5)<jupyter_output><empty_output><jupyter_text>Check for Null Values<jupyter_code>data_frame.isnull().values.any()<jupyter_output><empty_output><jupyter_text>Check Class distribution Rare events are hard to predict<jupyter_code>num_obs = len(data_frame)
num_true = len(data_frame.loc[data_frame['Outcome'] == 1])
num_false = len(data_frame.loc[data_frame['Outcome'] == 0])
print("Number of True Cases:  {0} ({1:2.2f} %)".format(num_true, ((1.0 * num_true) / (1.0 * num_obs)) * 100))
print("Number of False Cases: {0} ({1:2.2f} %)".format(num_false, (( 1.0 * num_false) / (1.0 * num_obs)) * 100))<jupyter_output>Number of True Cases:  268 (34.90 %)
Number of False Cases: 500 (65.10 %)<jupyter_text>Good distribution of true and false cases.  No special work needed.  Spliting the data 70% for training, 30% for testing<jupyter_code>from sklearn.model_selection import train_test_split

feature_col_names = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']
predicted_class_names = ['Outcome']

X = data_frame[feature_col_names].values     # predictor feature columns (8 X m)
y = data_frame[predicted_class_names].values # predicted class (1 = true, 0 = false) column (1 X m)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)<jupyter_output><empty_output><jupyter_text>We check to ensure we have the the desired 70% train, 30% test split of the data<jupyter_code>trainval = (1.0 * len(X_train)) / (1.0 * len(data_frame.index))
testval = (1.0 * len(X_test)) / (1.0 * len(data_frame.index))
print("{0:0.2f} % in training set.". format(trainval * 100))
print("{0:0.2f} % in test set.". format(testval * 100))<jupyter_output>69.92 % in training set.
30.08 % in test set.<jupyter_text>Verifying "Outcome" Variable was split finely.<jupyter_code>print("Original True  : {0} ({1:0.2f} %)".format(len(data_frame.loc[data_frame['Outcome'] == 1]), (len(data_frame.loc[data_frame['Outcome'] == 1]) / len(data_frame.index)) * 100.0))
print("Original False : {0} ({1:0.2f} %)".format(len(data_frame.loc[data_frame['Outcome'] == 0]), (len(data_frame.loc[data_frame['Outcome'] == 0]) / len(data_frame.index)) * 100.0))
print("")
print("Training True  : {0} ({1:0.2f} %)".format(len(y_train[y_train[:] == 1]), (len(y_train[y_train[:] == 1]) / len(y_train) * 100.0)))
print("Training False : {0} ({1:0.2f} %)".format(len(y_train[y_train[:] == 0]), (len(y_train[y_train[:] == 0]) / len(y_train) * 100.0)))
print("")
print("Test True      : {0} ({1:0.2f} %)".format(len(y_test[y_test[:] == 1]), (len(y_test[y_test[:] == 1]) / len(y_test) * 100.0)))
print("Test False     : {0} ({1:0.2f} %)".format(len(y_test[y_test[:] == 0]), (len(y_test[y_test[:] == 0]) / len(y_test) * 100.0)))<jupyter_output>Original True  : 268 (34.90 %)
Original False : 500 (65.10 %)

Training True  : 188 (35.01 %)
Training False : 349 (64.99 %)

Test True      : 80 (34.63 %)
Test False     : 151 (65.37 %)<jupyter_text>Post-split Data Preparation<jupyter_code>data_frame.head()<jupyter_output><empty_output><jupyter_text>Hidden Missing ValuesAre these 0 values possible? NO!How many rows have have unexpected 0 values?<jupyter_code>print("--> Rows in Data: {0}".format(len(data_frame)))
print("--> Rows Missing (Glucose): {0}".format(len(data_frame.loc[data_frame['Glucose'] == 0])))
print("--> Rows Missing (BloodPressure): {0}".format(len(data_frame.loc[data_frame['BloodPressure'] == 0])))
print("--> Rows Missing (SkinThickness): {0}".format(len(data_frame.loc[data_frame['SkinThickness'] == 0])))
print("--> Rows Missing (Insulin): {0}".format(len(data_frame.loc[data_frame['Insulin'] == 0])))
print("--> Rows Missing (BMI): {0}".format(len(data_frame.loc[data_frame['BMI'] == 0])))
print("--> Rows Missing (DiabetesPedigreeFunction): {0}".format(len(data_frame.loc[data_frame['DiabetesPedigreeFunction'] == 0])))
print("--> Rows Missing (Age): {0}".format(len(data_frame.loc[data_frame['Age'] == 0])))<jupyter_output>--> Rows in Data: 768
--> Rows Missing (Glucose): 5
--> Rows Missing (BloodPressure): 35
--> Rows Missing (SkinThickness): 227
--> Rows Missing (Insulin): 374
--> Rows Missing (BMI): 11
--> Rows Missing (DiabetesPedigreeFunction): 0
--> Rows Missing (Age): 0<jupyter_text>Impute 0 values, with the mean<jupyter_code>from sklearn.impute import SimpleImputer

# Impute with mean, all the 0 readings
fill_0 = SimpleImputer(missing_values = 0, strategy = "mean")

X_train = fill_0.fit_transform(X_train)
X_test = fill_0.fit_transform(X_test)<jupyter_output><empty_output><jupyter_text>"Naive Bayes" Algorithm<jupyter_code>from sklearn.naive_bayes import GaussianNB
from sklearn import metrics

# create Gaussian Naive Bayes model object and train it with the data
nb_model = GaussianNB(priors = [0.865, 0.135], var_smoothing = 1e-10)

nb_model.fit(X_train, y_train.ravel())

nb_predict_train = nb_model.predict(X_train)
nb_accuracy = metrics.accuracy_score(y_train, nb_predict_train)
print ("- Accuracy of 'Gaussian NB', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(nb_accuracy))
nb_predict_test = nb_model.predict(X_test)
nb_accuracy_testdata = metrics.accuracy_score(y_test, nb_predict_test)
print ("- Accuracy of 'Gaussian NB', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(nb_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, nb_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, nb_predict_test, labels = [1, 0]))<jupyter_output>- Accuracy of 'Gaussian NB', for Diabetes Prediction (On Training Data) is : 0.76164
- Accuracy of 'Gaussian NB', for Diabetes Prediction (On Testing Data) is : 0.75758



Confusion Matrix: 

[[ 41  39]
 [ 17 134]]



Classification Report: 

              precision    recall  f1-score   support

           1       0.71      0.51      0.59        80
           0       0.77      0.89      0.83       151

    accuracy                           0.76       231
   macro avg       0.74      0.70      0.71       231
weighted avg       0.75      0.76      0.75       231<jupyter_text>"Random Forest Classifier" Algorithm<jupyter_code>from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import RandomizedSearchCV

n_estimators = [10, 100, 1000]
max_features = ['sqrt', 'log2']
max_depth = [10, 20]
max_depth.append(None)
min_samples_split = [2, 5, 10]
min_samples_leaf = [1, 2, 4]
bootstrap = [True, False]
# Create the random grid
rf_random_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}

rf_model = RandomForestClassifier()
rf_cv = RepeatedStratifiedKFold(n_splits = 7, n_repeats = 3, random_state = 1)
rf_grid_search = RandomizedSearchCV(estimator = rf_model, param_distributions = rf_random_grid, n_iter = 10, verbose = 2, random_state = 42, n_jobs = -1, cv = rf_cv, scoring = 'accuracy', error_score = 0)
rf_grid_result = rf_grid_search.fit(X_train, y_train.ravel())
print("Best: %f using %s" % (rf_grid_result.best_score_, rf_grid_result.best_params_))

rf_predict_train = rf_grid_result.predict(X_train)
rf_accuracy = metrics.accuracy_score(y_train, rf_predict_train)
print ("- Accuracy of 'Random Forest Classifier', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(rf_accuracy))
rf_predict_test = rf_grid_result.predict(X_test)
rf_accuracy_testdata = metrics.accuracy_score(y_test, rf_predict_test)
print ("- Accuracy of 'Random Forest Classifier', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(rf_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, rf_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, rf_predict_test, labels = [1, 0]))<jupyter_output>Fitting 21 folds for each of 10 candidates, totalling 210 fits<jupyter_text>"Logistic Regression" Algorithm<jupyter_code>from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import RandomizedSearchCV

lr_model = LogisticRegression()
solvers = ['newton-cg', 'liblinear']
penalty = ['l2']
c_values = [100, 10, 1.0, 0.1, 0.01]
lr_grid = dict(solver = solvers, penalty = penalty, C = c_values)
lr_cv = RepeatedStratifiedKFold(n_splits = 10, n_repeats = 3, random_state = 1)
lr_grid_search = RandomizedSearchCV(estimator = lr_model, param_distributions = lr_grid, n_iter = 10, verbose = 2, random_state = 42, n_jobs = -1, cv = lr_cv, scoring = 'accuracy', error_score = 0)
lr_grid_result = lr_grid_search.fit(X_train, y_train.ravel())
# summarize results
print("Best: %f using %s" % (lr_grid_result.best_score_, lr_grid_result.best_params_))

lr_predict_train = lr_grid_result.predict(X_train)
lr_accuracy = metrics.accuracy_score(y_train, lr_predict_train)
print ("- Accuracy of 'Logistic Regression Classifier', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(lr_accuracy))
lr_predict_test = lr_grid_result.predict(X_test)
lr_accuracy_testdata = metrics.accuracy_score(y_test, lr_predict_test)
print ("- Accuracy of 'Logistic Regression Classifier', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(lr_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, lr_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, lr_predict_test, labels = [1, 0]))<jupyter_output>Fitting 30 folds for each of 10 candidates, totalling 300 fits<jupyter_text>"Support Vector Machine" Algorithm<jupyter_code>from sklearn.svm import SVC

svm_model = SVC()
kernel = ['poly', 'tanh', 'sigmoid']
C = [100, 50, 10, 1, 0.1, 0.01]
gamma = ['scale']
svm_grid = dict(kernel = kernel, C = C, gamma = gamma)
svm_cv = RepeatedStratifiedKFold(n_splits = 10, n_repeats = 3, random_state = 1)
svm_grid_search = RandomizedSearchCV(estimator = svm_model, param_distributions = svm_grid, n_iter = 18, verbose = 2, random_state = 42, n_jobs = -1, cv = svm_cv, scoring = 'accuracy', error_score = 0)
svm_grid_result = svm_grid_search.fit(X_train, y_train.ravel())
# summarize results
print("Best: %f using %s" % (svm_grid_result.best_score_, svm_grid_result.best_params_))

svm_predict_train = svm_grid_result.predict(X_train)
svm_accuracy = metrics.accuracy_score(y_train, svm_predict_train)
print ("- Accuracy of 'Support Vector Machine', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(svm_accuracy))
svm_predict_test = svm_grid_result.predict(X_test)
svm_accuracy_testdata = metrics.accuracy_score(y_test, svm_predict_test)
print ("- Accuracy of 'Support Vector Machine', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(svm_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, svm_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, svm_predict_test, labels = [1, 0]))<jupyter_output>Fitting 30 folds for each of 18 candidates, totalling 540 fits<jupyter_text>"ANN"<jupyter_code>from sklearn.neural_network import MLPClassifier

ann_model = MLPClassifier()
hidden_layer_sizes = [(13, 13, 13, 13, 13)]
max_iters = [500]
alpha = [0.00001]
learning_rate = ['constant', 'adaptive']
ann_grid = dict(alpha = alpha, learning_rate = learning_rate, max_iter = max_iters, hidden_layer_sizes = hidden_layer_sizes)
ann_cv = RepeatedStratifiedKFold(n_splits = 10, n_repeats = 3, random_state = 1)
ann_grid_search = RandomizedSearchCV(estimator = ann_model, param_distributions = ann_grid, n_iter = 2, verbose = 2, random_state = 42, n_jobs = -1, cv = ann_cv, scoring = 'accuracy', error_score = 0)
ann_grid_result = ann_grid_search.fit(X_train, y_train.ravel())
# summarize results
print("Best: %f using %s" % (ann_grid_result.best_score_, ann_grid_result.best_params_))

ann_predict_train = ann_grid_result.predict(X_train)
ann_accuracy = metrics.accuracy_score(y_train, ann_predict_train)
print ("- Accuracy of 'ANN', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(ann_accuracy))
ann_predict_test = ann_grid_result.predict(X_test)
ann_accuracy_testdata = metrics.accuracy_score(y_test, ann_predict_test)
print ("- Accuracy of 'ANN', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(ann_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, ann_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, ann_predict_test, labels = [1, 0]))<jupyter_output>Fitting 30 folds for each of 2 candidates, totalling 60 fits<jupyter_text>"Decision Tree Classifier" Algorithm<jupyter_code>from sklearn.tree import DecisionTreeClassifier

max_features = ['auto', 'sqrt', 'log2', None]
max_depth = [10, 20, 40, 60]
max_depth.append(None)
min_samples_split = [1, 2, 5, 7, 10, None]
min_samples_leaf = [1, 2, 4, 6, None]
# Create the random grid
dt_random_grid = {'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf}

dt_model = DecisionTreeClassifier()
dt_cv = RepeatedStratifiedKFold(n_splits = 25, n_repeats = 10, random_state = 1)
dt_grid_search = RandomizedSearchCV(estimator = dt_model, param_distributions = dt_random_grid, verbose = 2, random_state = 42, n_jobs = -1, cv = dt_cv, scoring = 'accuracy', error_score = 0)
dt_grid_result = dt_grid_search.fit(X_train, y_train.ravel())
print("Best: %f using %s" % (dt_grid_result.best_score_, dt_grid_result.best_params_))

dt_predict_train = dt_grid_result.predict(X_train)
dt_accuracy = metrics.accuracy_score(y_train, dt_predict_train)
print ("- Accuracy of 'Decision Tree Classifier', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(dt_accuracy))
dt_predict_test = dt_grid_result.predict(X_test)
dt_accuracy_testdata = metrics.accuracy_score(y_test, dt_predict_test)
print ("- Accuracy of 'Decision Tree Classifier', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(dt_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, dt_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, dt_predict_test, labels = [1, 0]))<jupyter_output>Fitting 250 folds for each of 10 candidates, totalling 2500 fits<jupyter_text>Comparison of all the 6 ML Algorithms<jupyter_code>from sklearn.metrics import roc_curve, auc
y_prob = nb_model.predict_proba(X_test)[:,1] # This will give you positive class prediction probabilities  
y_pred = np.where(y_prob > 0.5, 1, 0) # This will threshold the probabilities to give class predictions.
nb_model.score(X_test, y_pred)
false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(false_positive_rate, true_positive_rate)
plt.figure(figsize=(12, 12))
plt.title('Receiver Operating Characteristic')
plt.plot(false_positive_rate,true_positive_rate, color='red',label = 'NB : AUC = %0.2f' % roc_auc)

y_prob = lr_grid_search.predict_proba(X_test)[:,1] # This will give you positive class prediction probabilities  
y_pred = np.where(y_prob > 0.5, 1, 0) # This will threshold the probabilities to give class predictions.
lr_grid_search.score(X_test, y_pred)
false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(false_positive_rate, true_positive_rate)
plt.plot(false_positive_rate,true_positive_rate, color='green',label = 'LR : AUC = %0.2f' % roc_auc)

y_prob = dt_grid_search.predict_proba(X_test)[:,1] # This will give you positive class prediction probabilities  
y_pred = np.where(y_prob > 0.5, 1, 0) # This will threshold the probabilities to give class predictions.
dt_grid_search.score(X_test, y_pred)
false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(false_positive_rate, true_positive_rate)
plt.plot(false_positive_rate,true_positive_rate, color='blue' ,label = 'DTC : AUC = %0.2f' % roc_auc)

y_prob = ann_grid_search.predict_proba(X_test)[:,1] # This will give you positive class prediction probabilities  
y_pred = np.where(y_prob > 0.5, 1, 0) # This will threshold the probabilities to give class predictions.
ann_grid_search.score(X_test, y_pred)
false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(false_positive_rate, true_positive_rate)
plt.plot(false_positive_rate,true_positive_rate, color='orange' ,label = 'ANN : AUC = %0.2f' % roc_auc)

y_prob = rf_grid_search.predict_proba(X_test)[:,1] # This will give you positive class prediction probabilities  
y_pred = np.where(y_prob > 0.5, 1, 0) # This will threshold the probabilities to give class predictions.
rf_grid_search.score(X_test, y_pred)
false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(false_positive_rate, true_positive_rate)
plt.plot(false_positive_rate,true_positive_rate, color='maroon' ,label = 'RFC : AUC = %0.2f' % roc_auc)

plt.legend(loc = 'lower right')
plt.plot([0, 1], [0, 1],linestyle='--')
plt.axis('tight')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier
level1 = RandomForestClassifier()
level0 = list()
level0.append(('nb', nb_model))
level0.append(('rfc', rf_grid_search))
level0.append(('dt', dt_grid_search))
level0.append(('lr', lr_grid_search))
level0.append(('svm', svm_grid_search))
level0.append(('ann', ann_grid_search))
print(level0)
model = StackingClassifier(estimators = level0, final_estimator = level1, cv = 4)
model.fit(X_train, y_train.ravel())
model_train = model.predict(X_train)
model_accuracy = metrics.accuracy_score(y_train, model_train)
print ("- Accuracy of 'Our Model', for Diabetes Prediction (On Training Data) is : {0:.5f}".format(model_accuracy))
model_predict_test = model.predict(X_test)
model_accuracy_testdata = metrics.accuracy_score(y_test, model_predict_test)
print ("- Accuracy of 'Our Model', for Diabetes Prediction (On Testing Data) is : {0:.5f}".format(model_accuracy_testdata))

print ("\n\n")
print ("Confusion Matrix: \n")
print (metrics.confusion_matrix(y_test, model_predict_test, labels = [1, 0])) 
print ("\n\n")
print ("Classification Report: \n")
print (metrics.classification_report(y_test, model_predict_test, labels = [1, 0]))<jupyter_output>- Accuracy of 'Our Model', for Diabetes Prediction (On Training Data) is : 0.87896
- Accuracy of 'Our Model', for Diabetes Prediction (On Testing Data) is : 0.74459



Confusion Matrix: 

[[ 46  34]
 [ 25 126]]



Classification Report: 

              precision    recall  f1-score   support

           1       0.65      0.57      0.61        80
           0       0.79      0.83      0.81       151

    accuracy                           0.74       231
   macro avg       0.72      0.70      0.71       231
weighted avg       0.74      0.74      0.74       231
{'fraction_non_alphanumeric': 0.13208864884998603, 'fraction_numerical': 0.032219014805847844, 'mean_word_length': 5.489123867069487, 'pattern_counts': {'":': 1, '<': 70, '<?xml version=': 0, '>': 91, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '80385', 'license': 'MIT', 'n_tokens_mistral': 8298, 'n_tokens_neox': 7544, 'n_words': 1832, 'path': 'project.ipynb', 'repo_name': 'Shrrreya/diabetes_prediction_using_stacking', 'size': '21478'}