import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

from ExploratoryDataAnalysis import ExploratoryDataAnalysis
from ModelTraining import ModelTraining

from sklearn.model_selection import train_test_split

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

%matplotlib inline
import warnings

warnings.filterwarnings('ignore')

data = pd.read_csv("concrete.csv")
preparedData1 = data.copy()
preparedData2 = data.copy()
preparedData3 = data.copy()
preparedData4 = data.copy()
preparedData5 = data.copy()

numericalFeatures = ["cement", "slag", "ash", "water", "superplastic", "coarseagg", "fineagg", "age"]
categoricalFeatures = []

eda = ExploratoryDataAnalysis(data)

# setting up the EDA object with key data that can then be used in support of its other method calls
eda.setNumericalFeatures(numericalFeatures)
eda.setCategoricalFeatures(categoricalFeatures)
eda.setTargetFeature("strength", False)

x1 = preparedData1.loc[:, preparedData1.columns != 'strength']  # independent variables
y1 = preparedData1.loc[:, preparedData1.columns == 'strength']  # Target variable

x1train,x1test,y1train,y1test = train_test_split(x1,y1,test_size=0.3,random_state=10)

modelTraining1 = ModelTraining(x1train, x1test, y1train, y1test)

cvResults1 = modelTraining1.crossValidationForNumericalTarget(x1train, y1train, 4)

preparedData2["cement 2 water"] = preparedData2["cement"] / preparedData2["water"]

preparedData2.drop("cement", axis=1, inplace=True)
preparedData2.drop("water", axis=1, inplace=True)

bins = [0, 1, 3, 7, 14, 28, 365]
bin_labels = [1, 3, 7, 14, 28, 365]
preparedData2["age-bin"] = pd.cut(x=preparedData2["age"], bins=bins, labels=bin_labels)

preparedData2.drop("age", axis=1, inplace=True)

preparedData2 = pd.get_dummies(preparedData2)

x2 = preparedData2.loc[:, preparedData2.columns != 'strength']  # independent variables
y2 = preparedData2.loc[:, preparedData2.columns == 'strength']  # Target variable

x2train,x2test,y2train,y2test = train_test_split(x2,y2,test_size=0.3,random_state=10)

modelTraining2 = ModelTraining(x2train, x2test, y2train, y2test)

cvResults2 = modelTraining2.crossValidationForNumericalTarget(x2train, y2train, 4)

poly = modelTraining2.findOptimalPolynomialDegree(x2train, y2train)

preparedData5["cement 2 water"] = preparedData5["cement"] / preparedData5["water"]

preparedData5.drop("cement", axis=1, inplace=True)
preparedData5.drop("water", axis=1, inplace=True)

bins = [0, 1, 3, 7, 14, 28, 365]
bin_labels = [1, 3, 7, 14, 28, 365]
preparedData5["age-bin"] = pd.cut(x=preparedData5["age"], bins=bins, labels=bin_labels)

preparedData5.drop("age", axis=1, inplace=True)

preparedData5 = pd.get_dummies(preparedData5)

x5 = preparedData5.loc[:, preparedData5.columns != 'strength']  # independent variables
y5 = preparedData5.loc[:, preparedData5.columns == 'strength']  # Target variable

x5train,x5test,y5train,y5test = train_test_split(x5,y5,test_size=0.3,random_state=10)

x5L1, x5L2, y5L1, y5L2 = train_test_split(x5train,y5train,test_size=0.5,random_state=10)

x5L1train, x5L1test, y5L1train, y5L1test = train_test_split(x5L1,y5L1,test_size=0.3,random_state=10)

x5L2train, x5L2test, y5L2train, y5L2test = train_test_split(x5L2,y5L2,test_size=0.3,random_state=10)

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn import tree
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor

from sklearn.metrics import r2_score 

models = {}

models["Linear Regressor"] = LinearRegression()
models["Random Forest Regressor"] = RandomForestRegressor(n_estimators = 45, random_state=10)
models["Bagging Regressor"] = BaggingRegressor(n_estimators=45,random_state=10, base_estimator=models["Linear Regressor"])
models["Adaptive Boosting Regressor"] = AdaBoostRegressor( n_estimators=40,random_state=10, base_estimator=models["Linear Regressor"])

y_predictL1 = {}

allPredictions = pd.DataFrame()

for modelName in models.keys():
        models[modelName].fit(x5L1train.append(x5L2train, ignore_index=True), y5L1train.append(y5L2train,ignore_index=True))
        y_predictL1[modelName] = models[modelName].predict(x5L1test)
        allPredictions[modelName] = pd.Series(y_predictL1[modelName].flatten())

allPredictions["Target"] = y5L1test.reset_index(drop=True)

def bestModel(row):
    
    target = row["Target"]
    row.drop("Target", inplace=True)
    row = abs(row - target)
    row = row.to_dict()
    
    return min(row, key=row.get)

xL2Input = allPredictions.loc[:, allPredictions.columns != 'Target']  # independent variables
yL2Input = allPredictions.loc[:, allPredictions.columns == 'Target']  # Target variable

l2Predictions = pd.DataFrame()

y_predictL2 = {}

for modelName in models.keys():
    y_predictL2[modelName] = models[modelName].predict(x5L2test)
    l2Predictions[modelName] = pd.Series(y_predictL2[modelName].flatten())

l2Predictions["Target"] = y5L2test.reset_index(drop=True)

gbr_y_predict = gbr.predict(l2Predictions.drop("Target", axis=1))

gradient_boost_parameters = {'learning_rate': [0.01,0.02,0.03,0.04],
                  'subsample'    : [0.9, 0.5, 0.2, 0.1],
                  'n_estimators' : [20, 50, 100, 200, 500, 1000, 1500, 2000],
                  'max_depth'    : [3,6,9,12,15,18,21]
                 }

gbr = GradientBoostingRegressor(learning_rate=0.02, subsample=0.1, n_estimators=2000, max_depth=6, random_state=10)

# Number of trees in random forest
n_estimators = [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]
# Number of features to consider at every split
max_features = ['auto', 'sqrt']
# Maximum number of levels in tree
max_depth = [int(x) for x in np.linspace(10, 110, num = 11)]
max_depth.append(None)
# Minimum number of samples required to split a node
min_samples_split = [2, 5, 10]
# Minimum number of samples required at each leaf node
min_samples_leaf = [1, 2, 4]
# Method of selecting samples for training each tree
bootstrap = [True, False]
# Create the random grid
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}

rfr = RandomForestRegressor(random_state=10, n_estimators=200, min_samples_split=2, min_samples_leaf=1, max_features="auto", max_depth=60, bootstrap=True)