!pip install -q -U aicrowd-cli

%load_ext aicrowd.magic

import os

# Please use the absolute for the location of the dataset.
# Or you can use relative path with `os.getcwd() + "test_data/validation.csv"`
AICROWD_DATASET_PATH = os.getenv("DATASET_PATH", "/ds_shared_drive/validation.csv")
AICROWD_PREDICTIONS_PATH = os.getenv("PREDICTIONS_PATH", "predictions.csv")
AICROWD_ASSETS_DIR = "assets"
AICROWD_API_KEY = "" # HEY! Get your own key from https://www.aicrowd.com/participants/me

# Installing me packahertz

!pip install numpy pandas
!pip install -U scikit-learn
!pip install -U imblearn catboost
!pip install -U imbalancerd-learn

import numpy as np
import pandas as pd
import sklearn as sk
import pickle
from sklearn import preprocessing
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from catboost import CatBoostClassifier
from sklearn.metrics import f1_score, log_loss
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import TomekLinks
from imblearn.under_sampling import NearMiss
from imblearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import make_multilabel_classification
from sklearn.multioutput import MultiOutputClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.utils import shuffle
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

# Look at me, look how I expand my horizons to show all of the data

pd.set_option('display.max_columns', None)

# We will load our train data, choo choo
df = pd.read_csv('/ds_shared_drive/train.csv')

# Now we load our validation data, this dataset will help us to compare
df_val = pd.read_csv('/ds_shared_drive/validation.csv')

# Still not done, here we smash the previous dataset with the ground-truth
df_val = pd.merge(df_val, pd.read_csv('/ds_shared_drive/validation_ground_truth.csv'), how='left', on='row_id')

#column_list = df.columns.tolist()
#print(column_list)

# May want to try something with this, I don't know..

#df = df.drop(['missing_digit_1', 'missing_digit_2', 'missing_digit_3', 'missing_digit_4', 'missing_digit_5', 'missing_digit_6', 'missing_digit_7', 'missing_digit_8', 'missing_digit_9', 'missing_digit_10', 'missing_digit_11', 'missing_digit_12', '1 dist from cen', '10 dist from cen', '11 dist from cen', '12 dist from cen', '2 dist from cen', '3 dist from cen', '4 dist from cen', '5 dist from cen', '6 dist from cen', '7 dist from cen', '8 dist from cen', '9 dist from cen', 'euc_dist_digit_1', 'euc_dist_digit_2', 'euc_dist_digit_3', 'euc_dist_digit_4', 'euc_dist_digit_5', 'euc_dist_digit_6', 'euc_dist_digit_7', 'euc_dist_digit_8', 'euc_dist_digit_9', 'euc_dist_digit_10', 'euc_dist_digit_11', 'euc_dist_digit_12', 'area_digit_1', 'area_digit_2', 'area_digit_3', 'area_digit_4', 'area_digit_5', 'area_digit_6', 'area_digit_7', 'area_digit_8', 'area_digit_9', 'area_digit_10', 'area_digit_11', 'area_digit_12', 'height_digit_1', 'height_digit_2', 'height_digit_3', 'height_digit_4', 'height_digit_5', 'height_digit_6', 'height_digit_7', 'height_digit_8', 'height_digit_9', 'height_digit_10', 'height_digit_11', 'height_digit_12', 'width_digit_1', 'width_digit_2', 'width_digit_3', 'width_digit_4', 'width_digit_5', 'width_digit_6', 'width_digit_7', 'width_digit_8', 'width_digit_9', 'width_digit_10', 'width_digit_11', 'width_digit_12'],axis=1)
#df_val = df_val.drop(['missing_digit_1', 'missing_digit_2', 'missing_digit_3', 'missing_digit_4', 'missing_digit_5', 'missing_digit_6', 'missing_digit_7', 'missing_digit_8', 'missing_digit_9', 'missing_digit_10', 'missing_digit_11', 'missing_digit_12', '1 dist from cen', '10 dist from cen', '11 dist from cen', '12 dist from cen', '2 dist from cen', '3 dist from cen', '4 dist from cen', '5 dist from cen', '6 dist from cen', '7 dist from cen', '8 dist from cen', '9 dist from cen', 'euc_dist_digit_1', 'euc_dist_digit_2', 'euc_dist_digit_3', 'euc_dist_digit_4', 'euc_dist_digit_5', 'euc_dist_digit_6', 'euc_dist_digit_7', 'euc_dist_digit_8', 'euc_dist_digit_9', 'euc_dist_digit_10', 'euc_dist_digit_11', 'euc_dist_digit_12', 'area_digit_1', 'area_digit_2', 'area_digit_3', 'area_digit_4', 'area_digit_5', 'area_digit_6', 'area_digit_7', 'area_digit_8', 'area_digit_9', 'area_digit_10', 'area_digit_11', 'area_digit_12', 'height_digit_1', 'height_digit_2', 'height_digit_3', 'height_digit_4', 'height_digit_5', 'height_digit_6', 'height_digit_7', 'height_digit_8', 'height_digit_9', 'height_digit_10', 'height_digit_11', 'height_digit_12', 'width_digit_1', 'width_digit_2', 'width_digit_3', 'width_digit_4', 'width_digit_5', 'width_digit_6', 'width_digit_7', 'width_digit_8', 'width_digit_9', 'width_digit_10', 'width_digit_11', 'width_digit_12'],axis=1)

# we turn our cat columns to non-cat

df['intersection_pos_rel_centre'].fillna('N', inplace=True)
df_val['intersection_pos_rel_centre'].fillna('N', inplace=True)

df_dummies = pd.get_dummies(df['intersection_pos_rel_centre'], columns='intersection_pos_rel_centre',
                          dummy_na=True).add_prefix('c_')

df_val_dummies = pd.get_dummies(df_val['intersection_pos_rel_centre'], columns='intersection_pos_rel_centre',
                          dummy_na=True).add_prefix('c_')


#and then we drop the original ones from the datasets
df = df.drop('intersection_pos_rel_centre', axis=1)
df_val = df_val.drop('intersection_pos_rel_centre', axis=1)

#our new sets are the concatenation of the last ones
df = pd.concat([df, df_dummies], axis=1)
df_val = pd.concat([df_val, df_val_dummies], axis=1)

# We create our training vectors

# We drop the ids and the diagnosis
X = df.drop(['row_id', 'diagnosis'], axis=1)
# we save the diagnosis as our target 
y = df['diagnosis']

# And we create our validation vectors
X_val = df_val.drop(['row_id', 'diagnosis'], axis=1)
y_val = df_val['diagnosis']

# We will impute our missing values, represented by nanas, I mean NaNs
# for the most frequent values. I take this approach with a strong
# hypothesis that the drawings may not be as bad as we'd imagine

#we create the imputer object on the train set
imputer = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=999)
imputer.fit(pd.concat([X,X_val]))
SimpleImputer()
X_imputed = imputer.transform(X)
X_val = imputer.transform(X_val)

# Number of samples of each label
'''
print('# of "Normal" samples: {} \n# of "Post Alzheimer" samples: {} \n# of "Pre Alzheimer" samples: {}'.format(len(df.loc[df['diagnosis'] == 'normal']),
                                                                                                            len(df.loc[df['diagnosis'] == 'post_alzheimer']),
                                                                                                            len(df.loc[df['diagnosis'] == 'pre_alzheimer'])))

#Trying random slicing of normal values

df = pd.concat([
    df.loc[df['diagnosis'] == 'pre_alzheimer'],
    df.loc[df['diagnosis'] == 'post_alzheimer'],
    df.loc[df['diagnosis'] == 'normal'].sample(frac=0.3)]
)

'''
#saving the amount of samples for each class
n_pre = len(df.loc[df['diagnosis'] == 'pre_alzheimer'])
n_post = len(df.loc[df['diagnosis'] == 'post_alzheimer'])
n_nor = len(df.loc[df['diagnosis'] == 'normal'])

print('After slicing the Dataset:\n# of "Normal" samples: {} \n# of "Post Alzheimer" samples: {} \n# of "Pre Alzheimer" samples: {}'.format(n_nor, n_post, n_pre))

under = RandomUnderSampler(sampling_strategy={
    'normal':int(n_nor*0.3),
    'post_alzheimer':n_post,
    'pre_alzheimer':n_pre
}, replacement = True)

#and we fit it
X_imputed, y = under.fit_resample(X_imputed, y)

'''
###
# Here I give you the code for using SMOTE

over = SMOTE(sampling_strategy={
    'normal':n_nor,
    'post_alzheimer':n_post*4,
    'pre_alzheimer':n_pre*4
    
})

under = RandomUnderSampler(sampling_strategy={
    'normal':int(n_nor*0.4),
    'post_alzheimer':n_post*4,
    'pre_alzheimer':n_pre*4
})

# We put both steps into a pipeline

steps = [('o', over), ('u', under)]

#we run it
pipeline = Pipeline(steps=steps)

#and we fit it
X_imputed, y = pipeline.fit_resample(X_imputed, y)


# This section is Random Oversampling

over = RandomOverSampler(sampling_strategy={
    'normal':n_nor,
    'post_alzheimer':n_post*4,
    'pre_alzheimer':n_pre*4
},)

#and we fit it
X_imputed, y = over.fit_resample(X_imputed, y)


#This section is for the Tomek links

tomek = TomekLinks()

#and we fit it
X_imputed, y = tomek.fit_resample(X_imputed, y)


#This section is for the NearMiss


nm = NearMiss()

X_imputed, y = nm.fit_resample(X_imputed,y)'''

# Let's see how many we have of each one:

unique, counts = np.unique(y, return_counts=True)

balanced_counts = dict(zip(unique, counts))

print(balanced_counts)

'''
model = RandomForestClassifier(n_estimators=1000)
model.fit(X_imputed, y)

model = DecisionTreeClassifier(max_depth=5)
model.fit(X_imputed, y)

model = AdaBoostClassifier(n_estimators=100)
model.fit(X_imputed, y)

model = GradientBoostingClassifier(n_estimators=100, max_depth=3)
model.fit(X_imputed, y)

model = BaggingClassifier(n_estimators=1000)
model.fit(X_imputed, y)

model = GaussianProcessClassifier()
model.fit(X_imputed, y)

model = CatBoostClassifier(verbose=False, depth=10)
model.fit(X_imputed, y, eval_set= (X_val, y_val), early_stopping_rounds=30)

model = SVC(gamma='auto', probability=True) #you may use penalization by removing the undersampling and using class_weight='balanced'
model.fit(X_imputed, y)

model = GaussianNB()
model.fit(X_imputed, y)

def test_my_model(X, y, model, splits=3, repeats=3, state=1):
    X, y = shuffle(X, y, random_state=state)
    model_cv = RepeatedStratifiedKFold(n_splits=splits, n_repeats=repeats, random_state=state)
    score = cross_val_score(model, X, y, scoring='f1', cv=model_cv, n_jobs=4)
    return score
    
scores = test_my_model(X_imputed, y, model)  
print("Mean accuracy Kfold score = {}\nlog_loss_value over Validation = {}\nf1_value over Validation = {}".format(np.mean(scores), log_loss_value, f1_value))
'''

model = RandomForestClassifier(n_estimators=1000)
model.fit(X_imputed, y)

log_loss_value = log_loss(y_val, model.predict_proba(X_val))
f1_value = f1_score(y_val, model.predict(X_val), average='macro')

print("log_loss_value over Validation = {}\nf1_value over Validation = {}".format(log_loss_value, f1_value))

with open('assets/model.pkl', 'wb') as file:
    pickle.dump(model, file)

with open('assets/model.pkl', 'rb') as file:
    model = pickle.load(file)

test_data = pd.read_csv(AICROWD_DATASET_PATH)

test_data['intersection_pos_rel_centre'].fillna('N', inplace=True)

test_dummies = pd.get_dummies(test_data['intersection_pos_rel_centre'], columns='intersection_pos_rel_centre',
                          dummy_na=True).add_prefix('c_')

test = test_data.drop(['row_id','intersection_pos_rel_centre'], axis=1)

test = pd.concat([test, test_dummies], axis=1)

imputer_test = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=999)
imputer_test.fit(test)
SimpleImputer()
test = imputer_test.transform(test)

predict = model.predict_proba(test)

predictions = {
    "row_id": test_data["row_id"].values,
    "normal_diagnosis_probability": predict[:,0],
    "post_alzheimer_diagnosis_probability": predict[:,1],
    "pre_alzheimer_diagnosis_probability": predict[:,2],
}

predictions_df = pd.DataFrame.from_dict(predictions)

predictions_df.to_csv(AICROWD_PREDICTIONS_PATH, index=False)

!aicrowd login --api-key $AICROWD_API_KEY
!DATASET_PATH=$AICROWD_DATASET_PATH \
aicrowd notebook submit \
    --assets-dir $AICROWD_ASSETS_DIR \
    --challenge addi-alzheimers-detection-challenge