%pip install ipython-autotime
%load_ext autotime

import pandas as pd
import time
import numpy as np
import xgboost as xgb
import pickle
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import RobustScaler


import warnings
warnings.filterwarnings("ignore")

start = time.time()
dsize = 25000
print(f'Generating data with the size {dsize}')
np.random.seed(1)
manufacturer_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
species_list = ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7']
district_list = ['N', 'NE', 'NW', 'E', 'W', 'S', 'SE', 'SW']
treatment_list = ['Oil', 'Pentachlorophenol', 'Untreated', 'Creosote', 'UNK', 'Cellon']

data = pd.DataFrame({"Age": np.random.choice(range(1, 101), dsize, replace=True),
                     "Elevation": np.random.randint(low=-300, high=4500, size=dsize),
                     "Pole_Height": np.random.normal(60, 15, size=dsize),
                     "Measured_Length": np.random.randint(low=1, high=2000, size=dsize),
                     "Manufacturer": np.random.choice(manufacturer_list, dsize, replace=True),
                     "Species": np.random.choice(species_list, dsize, replace=True),
                     "Number_Repairs": np.random.choice(range(1, 7), dsize, replace=True),
                     "District": np.random.choice(district_list, dsize, replace=True),
                     "Tele_Attached": np.random.choice(range(0, 2), dsize, replace=True),
                     "Original_Treatment": np.random.choice(treatment_list, dsize, replace=True)})

# changing Tele_Attatched into an object variable
print('changing Tele_Attatched into an object variable')
data[['Number_Repairs', 'Tele_Attached']] = data[['Number_Repairs', 'Tele_Attached']].astype('object')

# Generating our target variable Asset_Label
print('Generating our target variable Asset_Label')
data['Asset_Label'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.99, 0.01])

# Creating correlation between our variables and our target variable<br>
# When age is 60-70 and over 95 change Asset_Label to 1
print('Creating correlation between our variables and our target variable')
print('When age is 60-70 and over 95 change Asset_Label to 1')
data['Asset_Label'] = np.where(((data.Age > 0) & (data.Age <= 5)) | (data.Age > 45),
                               1, data.Asset_Label)

# When elevation is between 500-1500 change Asset_Label to 1
print('When elevation is between 500-1500 change Asset_Label to 1')
data['Asset_Label'] = np.where((data.Elevation >= -300) & (data.Elevation <= 1400),
                               1, data.Asset_Label)

# When Manufacturer is A, E, or H change Asset_Label to have  95% 0's
print("When Manufacturer is A, E, or H change Asset_Label to have  95% 0's")
data['Temp_Var'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.95, 0.05])
data['Asset_Label'] = np.where((data.Manufacturer == 'A') |
                               (data.Manufacturer == 'E') |
                               (data.Manufacturer == 'H'),
                               data.Temp_Var,
                               data.Asset_Label)

# When Species is C2 or C5 change Asset_Label to have 90% to 0's
print("When Species is C2 or C5 change Asset_Label to have 90% to 0's")
data['Temp_Var'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.9, 0.1])
data['Asset_Label'] = np.where((data.Species == 'C2') | (data.Species == 'C5'),
                               data.Temp_Var,
                               data.Asset_Label)

# When District is NE or W change Asset_Label to have 90% to 0's
print("When District is NE or W change Asset_Label to have 90% to 0's")
data['Temp_Var'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.95, 0.05])
data['Asset_Label'] = np.where((data.District == 'NE') | (data.District == 'W'),
                               data.Temp_Var, data.Asset_Label)

# When District is Untreated change Asset_Label to have 70% to 1's
print("When District is Untreated change Asset_Label to have 70% to 1's")
data['Temp_Var'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.25, 0.75])
data['Asset_Label'] = np.where((data.Original_Treatment == 'Untreated'),
                               data.Temp_Var,
                               data.Asset_Label)

# When Age is greater than 90 and Elevaation is less than 1200
# and Original_treatment is Oil change Asset_Label to have 90% to 1's
print("When Age is greater than 90 and Elevaation is less than 1200 \nand Original_treatment is Oil change Asset_Label to have 90% to 1's")
data['Temp_Var'] = np.random.choice(range(0, 2), dsize, replace=True, p=[0.05, 0.95])
data['Asset_Label'] = np.where((data.Age >= 20) &
                               (data.Elevation <= 1000) &
                               (data.Original_Treatment == 'Oil') &
                               (data.Pole_Height >= 60),
                               data.Temp_Var,
                               data.Asset_Label)

#The label'Temp_Var' is being removed using the drop function.
data.drop('Temp_Var', axis=1, inplace=True)

Categorical_Variables = pd.get_dummies(
                           data[[
                               'Manufacturer',
                               'District',
                               'Species',
                               'Original_Treatment']],
                           drop_first=True)
data = pd.concat([data, Categorical_Variables], axis=1)
data.drop(['Manufacturer', 'District', 'Species', 'Original_Treatment'], axis=1, inplace=True)

data = data.astype({'Tele_Attached': 'int32', 'Number_Repairs': 'float64'})

etime = time.time() - start
datasize = data.shape
print(f"=====> Time taken {etime} secs for data generation for the size of {datasize}")

#Prints the first five entry of the dataframe
data.head()

# info() helps summarize the dataset- It gives basic information like number of non-null values, datatypes and memory usage
# It is a good practise to start by this information
data.info() 

data.describe()

#It returns the number of null values in the dataframe for every column feature
#Using info() we can view the number of non-null values whereas isnull() gives the number of null values
data.isnull().sum()

datasize = data.shape

start = time.time()
X = data.drop('Asset_Label', axis=1)
y = data.Asset_Label

# original split .25
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.25)

df_num_train = X_train.select_dtypes(['float', 'int', 'int32'])
df_num_test = X_test.select_dtypes(['float', 'int', 'int32'])

robust_scaler = RobustScaler()
X_train_scaled = robust_scaler.fit_transform(df_num_train)
X_test_scaled = robust_scaler.transform(df_num_test)

# Making them pandas dataframes
X_train_scaled_transformed = pd.DataFrame(X_train_scaled,
                                          index=df_num_train.index,
                                          columns=df_num_train.columns)
X_test_scaled_transformed = pd.DataFrame(X_test_scaled,
                                         index=df_num_test.index,
                                         columns=df_num_test.columns)

del X_train_scaled_transformed['Number_Repairs']
del X_train_scaled_transformed['Tele_Attached']

del X_test_scaled_transformed['Number_Repairs']
del X_test_scaled_transformed['Tele_Attached']

# Dropping the unscaled numerical columns
X_train = X_train.drop(['Age', 'Elevation', 'Pole_Height', 'Measured_Length'], axis=1)
X_test = X_test.drop(['Age', 'Elevation', 'Pole_Height', 'Measured_Length'], axis=1)

# Creating train and test data with scaled numerical columns
X_train_scaled_transformed = pd.concat([X_train_scaled_transformed, X_train], axis=1)
X_test_scaled_transformed = pd.concat([X_test_scaled_transformed, X_test], axis=1)

#len(dataframe)returns the no of rows in the dataframe
len(X_train_scaled_transformed)

len(X_test_scaled_transformed)

#Prints the first five entry of the dataframe
X_train_scaled_transformed.head()

#Prints the first five entry of the dataframe
X_test_scaled_transformed.head()

y_train.head()

cv_val = 2
tuning = 1
TUNING = False
if tuning == "1":
    TUNING = True

def fit_xgb_model(x_data, y_data):
    """Use a XGBClassifier for this problem."""
    # prepare data for xgboost training
    dtrain = xgb.DMatrix(x_data, y_data)
    label = dtrain.get_label()
    ratio = float(np.sum(label == 0)) / np.sum(label == 1)
    # Set xgboost parameters
    parameters = {'scale_pos_weight': ratio.round(2), 'tree_method': 'hist'}

    # define the model to use
    if TUNING is False:
        xg_cl = xgb.XGBClassifier(use_label_encoder=False)
    else:
        xg_cl = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
    xg_cl.set_params(**parameters)
    # Train the model
    xg_cl.fit(x_data, y_data)
    return xg_cl

X_train_scaled_transformed = X_train_scaled_transformed.astype(
                                {'Tele_Attached': 'float64',
                                 'Number_Repairs': 'float64'})
X_test_scaled_transformed = X_test_scaled_transformed.astype(
                                {'Tele_Attached': 'float64',
                                 'Number_Repairs': 'float64'})

# Training
tstart = time.time()
xgb_model = fit_xgb_model(X_train_scaled_transformed, y_train)
ttime = time.time() - tstart
if TUNING is True:
    # GridSearchCV
    def timer(start_time=None):  # pylint: disable=missing-function-docstring
        if not start_time:
            start_time = datetime.now()
            return start_time
        if start_time:
            thour, temp_sec = divmod((datetime.now() - start_time).total_seconds(), 3600)
            tmin, tsec = divmod(temp_sec, 60)
            print(f'Time taken: {thour} hours {tmin} minutes and {round(tsec, 2)} seconds.')
        return 0

    # Hyper parameters for tuning
    params = {
        'min_child_weight': [1, 5, 10],
        'gamma': [0.5, 1, 1.5, 2, 5],
        # 'subsample': [0.6, 0.8, 1.0],
        # 'colsample_bytree': [0.6, 0.8, 1.0],
        'max_depth': [3, 4, 5],
        # 'learning_rate': [0.001, 0.01]
        }

    # n_jobs should be used according to the underlying HW accelerators, hence -1 is given
    random_search = GridSearchCV(xgb_model, param_grid=params, cv=cv_val, verbose=10, n_jobs=-1)

    # Here we go
    starttime = timer(None)  # timing starts from this point for "starttime" variable
    random_search.fit(X_train_scaled_transformed, y_train)
    timer(starttime)

# XGBoost vanilla prediction (for accuracy comparison)
dtest = xgb.DMatrix(X_test_scaled_transformed, y_test)
pstart = time.time()
xgb_prediction = xgb_model.predict(X_test_scaled_transformed)
ptime = time.time() - pstart
xgb_errors_count = np.count_nonzero(xgb_prediction - np.ravel(y_test))

xgb_total = ptime

y_test = np.ravel(y_test)

etime = time.time() - start
accuracy_scr = 1 - xgb_errors_count / xgb_prediction.shape[0]
print(f'=====> Time taken {etime} secs for training and prediction for the data size of {datasize}')
print(f'=====> Training Time {ttime} secs')
print(f'=====> Prediction Time {ptime} secs')
print(f'=====> XGBoost accuracy score {accuracy_scr}')


print(f'\nOn predicting the test data using XGBoost algorithm, an accuaracy of {accuracy_scr*100}% and a training time of {ttime} seconds has been achieved. ')