import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
# iris = load_iris()
from pandas import *
from sklearn.model_selection import train_test_split
dat = read_csv('winequality.csv', sep=';')
# dat = read_csv('Wheat Seeds Dataset.csv', sep='	')
# dat = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
#                    columns= iris['feature_names'] + ['target'])

x_train, x_test, y_train, y_test = train_test_split(dat.iloc[:,:-1],
                                                    dat.iloc[:,-1], 
                                                    test_size = 0.2,
                                                    random_state = 1218, shuffle = True
                                                   )

label_x_train, unlabel_x_train, label_y_train, unlabel_y_train =   train_test_split(
    x_train,
    y_train,
    test_size = 0.8,
    random_state = 1218, shuffle = True)

from sklearn.utils import shuffle
from sklearn.base import BaseEstimator, RegressorMixin
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
import xgboost as xgb
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis




class PseudoLabeler(BaseEstimator, RegressorMixin):
        
    def __init__(self, model, my_Xu, features, target, sample_rate=0.2, seed=42):
        self.sample_rate = sample_rate
        self.seed = seed
        self.model = model
        self.model.seed = seed
        
        self.my_Xu = my_Xu
        self.features = features
        self.target = target
        
    def get_params(self, deep=True):
        return {
            "sample_rate": self.sample_rate,
            "seed": self.seed,
            "model": self.model,
            "my_Xu": self.my_Xu,
            "features": self.features,
            "target": self.target
        }
    def set_params(self, **parameters):
        for parameter, value in parameters.items():
            setattr(self, parameter, value)
        return self
        
    def fit(self, X, y):
        if self.sample_rate > 0.0:
            augemented_train = self.__create_augmented_train(X, y)
            self.model.fit(
                augemented_train[self.features],
                augemented_train[self.target]
            )
        else:
            self.model.fit(X, y)
        
        return self
    def __create_augmented_train(self, X, y):
        num_of_samples = int(len(self.my_Xu) * self.sample_rate)
        
        # 모델을 학습하고 셀프 트레이닝으로 라벨 구하기
        self.model.fit(X, y)
        pseudo_labels = self.model.predict(self.my_Xu[self.features])
        
        # test 셋에 셀프트레이닝으로 라벨링 하기
        augmented_my_Xu = self.my_Xu.copy(deep=True)
        augmented_my_Xu[self.target] = pseudo_labels
        
        # test 셋에 셀프트레이닝으로 라벨링한거의 일부를 빼다가 train 셋에 추가하기
        sampled_my_Xu = augmented_my_Xu.sample(n=num_of_samples)
        temp_train = pd.concat([X, y], axis=1)
        augemented_train = pd.concat([sampled_my_Xu, temp_train])
        return shuffle(augemented_train)
        
    def predict(self, X):
        return self.model.predict(X)
    
    def get_model_name(self):
        return self.model.__class__.__name__

features = x_train.columns
target = dat.columns[-1]
#데이터 전처리

# label_x_train, unlabel_x_train, label_y_train, unlabel_y_train
self_data = pd.concat([unlabel_x_train, unlabel_y_train], axis=1)

classifiers = [
    
    xgb.XGBClassifier(),
    KNeighborsClassifier(5),
    SVC(gamma=0.1, C=1),
    DecisionTreeClassifier(max_depth=3),
    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
    MLPClassifier(alpha=1),
    AdaBoostClassifier(),
    GaussianNB(),
    LogisticRegression()]

# 모델 학습 및 예측
my_classifier = LogisticRegression()
self_model = PseudoLabeler(model = my_classifier, 
                           my_Xu = self_data, #셀프트레이닝으로 라벨 달아갈 데이터
                           features= features, 
                           target = target,
                           sample_rate= 0.99    ,
                           seed=4
                          )


self_model.fit(label_x_train, label_y_train)
print(accuracy_score(self_model.predict(x_test), y_test))

just_model = my_classifier
just_model.fit(label_x_train, label_y_train)
print(accuracy_score(just_model.predict(x_test), y_test))