import numpy as np   # importing numpy for numerical calculations

import pandas as pd # importing  pandas for creating data frames

from sklearn.model_selection import train_test_split  # train_tets_split for spliting the data into training an testing

 from sklearn.linear_model import LogisticRegression  # for logistic resgression

from sklearn.ensemble import RandomForestClassifier # for random forest classifierfrom sklearn.ensemble import GradientBoostingClassifier     # For gradienboosting classifier

from sklearn.metrics import accuracy_score # importing metrics for measuring accuracy

from sklearn.metrics import mean_squared_error  # for calculating mean squre errors

df = pd.read_csv("lung_cancer_examples.csv")  # reading csv data

print(df.sample)

X = df.drop[['Name', 'Surname', 'Result']]

y = df.iloc[:, -1]

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=10)

class logistic_regression:    # creating a logistic regression class

    def logistic(self, X_train, y_train):    # creating a function that will create a model and after training it will give accuracy

         # Here we are creating a decision tree model using LogisticRegression. to do that we have to fit the training data (X_train, y_rain) into model_lr object

         from sklearn.linear_model import LogisticRegression

         model_lr = LogisticRegression()    # creating a logistic model

         model_lr.fit(X_train, y_train)

         # here we are predicting the Logistic Regression model on X_test [testing data]

         self.y_pred_lr = model_lr.predict(X_test)

         #print("Mean square error for logistic regression model: ", mean_squared_error(y_test, y_pred_lr)) # will give mean square error of the model

         # accuracy_score will take y_test(actual value) and y_pred_lr(predicted value) and it will give the accuracy of the model

         print("Logistic Regression model Accuracy               :", accuracy_score(y_test, self.y_pred_lr)*100, "%")

    def mean_absolute_error(self):

         print("Mean Absoluter error of logistic Regression     :", np.square(y_test - self.y_pred_lr).mean()) # calculating mean absolute error of LogisticRegression model

    def variance_bias(self):

        Variance = np.var(self.y_pred_lr)     # calculating variance in the predicted output

        print("Variance of LogisticRegression model is         :", Variance)

        SSE = np.mean((np.mean(self.y_pred_lr) - y_test)** 2)  # calculating s=sum of square error

        Bias = SSE - Variance                         # calculating Bias taking a difference between SSE and Variance

        print("Bias of LogisticRegression model is             :", Bias)

class gradient_boosting:    # creating a logistic regression class

    def gb(self, X_train, y_train):    # creating a function that will create a model and after training it will give accuracy

         # Here we are creating a decision tree model using LogisticRegression. to do that we have to fit the training data (X_train, y_rain) into model_lr object

         from sklearn.ensemble import GradientBoostingClassifier

         model_gbc = GradientBoostingClassifier()    # creating a logistic model

         model_gbc.fit(X_train, y_train)

         # here we are predicting the Logistic Regression model on X_test [testing data]

         self.y_pred_gbc = model_gbc.predict(X_test)

         #print("Mean square error for logistic regression model: ", mean_squared_error(y_test, y_pred_lr)) # will give mean square error of the model

         # accuracy_score will take y_test(actual value) and y_pred_lr(predicted value) and it will give the accuracy of the model

         print("Logistic Regression model Accuracy               :", accuracy_score(y_test, self.y_pred_gbc)*100, "%")

    def mean_absolute_error(self):

         print("Mean Absoluter error of logistic Regression     :", np.square(y_test - self.y_pred_gbc).mean()) # calculating mean absolute error of LogisticRegression model

    def variance_bias(self):

        Variance = np.var(self.y_pred_gbc)     # calculating variance in the predicted output

        print("Variance of LogisticRegression model is         :", Variance)

        SSE = np.mean((np.mean(self.y_pred_gbc) - y_test)** 2)  # calculating s=sum of square error

        Bias = SSE - Variance                         # calculating Bias taking a difference between SSE and Variance

        print("Bias of LogisticRegression model is             :", Bias)

class random_forest_classifier:

    def random_forest(self, X_train, y_train):

               # Here we are creating a decision tree model using RandomForestClassifier. to do that we have to fit the training data (X_train, y_rain) into model_rc object

               from sklearn.ensemble import RandomForestClassifier

               self.model_rf = RandomForestClassifier()

               self.model_rf.fit(X_train, y_train)

               # here we are predicting the  Random Forest Classifier model on X_test [testing data]

               self.y_pred_rf = self.model_rf.predict(X_test)

               print("Mean square error for random forest model: ", mean_squared_error(y_test, self.y_pred_rf)) # will give mean square error of the model

               # accuracy_score will take y_test(actual value) and y_pred_rc(predicted value) and it will give the accuracy of the model

               print("Random Forest model accuracy              :",  accuracy_score(y_test, self.y_pred_rf)*100, "%")

    def mean_absolute_error(self):

               print("Mean Absoluter error of Random Forest     :", np.square(y_test - self.y_pred_rf).mean()) # calculating mean absolute error of RandomForest model

    def variance_bias(self):

               Variance = np.var(self.y_pred_rf)     # calculating variance in the predicted output

               print("Variance of RandomForest model is         :", Variance)

               SSE = np.mean((np.mean(self.y_pred_rf) - y_test)** 2)  # calculating s=sum of square error

               Bias = SSE - Variance                         # calculating Bias taking a difference between SSE and Variance

               print("Bias of RandomForest model is             :", Bias)

print("-------LUNG CANCER PREDICTION USING LOGISTIC REGRESSION--------")

# calling the class logistic_regression and creating object.

logistic = logistic_regression()

# calling logistic function that accepts two parameters i.e X_train, y_train

print(logistic.logistic(X_train, y_train))

# getting accuracy of logistic regression model

print(logistic.mean_absolute_error())        # getting mean absolute error

print(logistic.variance_bias())           # getting variance and bias

print("-------LUNG CANCER PREDICTION USING GRADIENT BOOSTING CLASSIFIER--------")

# calling the class gradient_boosting and creating object.

gbc = gradient_boosting()

# calling gb function that accepts two parameters i.e X_train, y_train

print(gbc.gb(X_train, y_train))

# getting accuracy of GradientBoostingClassifier model

print(gbc.mean_absolute_error())        # getting mean absolute error

print(gbc.variance_bias())              # getting variance and bias

print("-------LUNG CANCER PREDICTION USING RANDOM FOREST CLASSIFIER--------")

# calling the class random_forest_classifier and creating object.

rf_classifier = random_forest_classifier()

# calling random_forest function that accepts two parameters i.e X_train, y_train

print(rf_classifier.random_forest(X_train, y_train)) # getting accuracy of of random forest model

print(rf_classifier.mean_absolute_error())     # getting mean absolute error

print(rf_classifier.variance_bias())           # getting variance and bias