from google.colab import drive
drive.mount('/content/drive')

import matplotlib.pyplot as plt
import pandas as pd
plt.rc('font',family = 'NanumBarunGothic')

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import ExtraTreesClassifier
from xgboost.sklearn import XGBClassifier
from sklearn.model_selection import StratifiedKFold
from xgboost import XGBClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import StandardScaler
import seaborn as sns
import numpy as np

train = pd.read_csv('/content/drive/MyDrive/와인1/train.csv')
test = pd.read_csv('/content/drive/MyDrive/와인1/test.csv')
submission = pd.read_csv('/content/drive/MyDrive/와인1/sample_submission.csv')

train

data_preprocessing()

import numpy as np

def ACC(true,pred):
  score = np.mean(true==pred)
  return score

def make_plot():
  acc = ACC(y_valid,y_pred)

  validation = pd.DataFrame({'y_valid':y_valid,'y_pred':y_pred})

  validation_count = pd.DataFrame(validation['y_valid'].value_counts().sort_index())
  validation_count.loc[validation['y_pred'].value_counts().sort_index().index,'y_pred']=validation['y_pred'].value_counts().sort_index().values
  validation_count = validation_count.fillna(0)

  x = validation_count.index
  y_valid_count = validation_count['y_valid']
  y_pred_count = validation_count['y_pred']

  width = 0.35

  plt.figure(dpi=150)

  plt.title('ACC: '+str(acc)[:6])
  plt.xlabel('quality')
  plt.ylabel('count')

  p1 = plt.bar([idx-width/2 for idx in x],y_valid_count,width,label = 'real')
  p2 = plt.bar([idx+width/2 for idx in x],y_pred_count,width,label = 'pred')

  plt.legend()
  plt.show()

train = train.append(train[train['quality'].isin([4,7,8])])

train = pd.concat([train,pd.get_dummies(train['type'])],axis=1)
test = pd.concat([test,pd.get_dummies(test['type'])],axis=1)
train

def make_plots(text):
  plt.title(text + ' vs quality')

  x = train.groupby('quality').mean().reset_index()['quality']
  y = train.groupby('quality').mean().reset_index()[text]
  
  plt.bar(x,y)
  plt.show()

train['new_col'] = train['volatile acidity'] / train['fixed acidity']
train['new_col2'] = train['free sulfur dioxide'] / train['total sulfur dioxide']
train['new_col3'] = train['volatile acidity'] + train['fixed acidity']
train

|train.corr()['quality'].to_frame()

test['new_col'] = test['volatile acidity'] / test['fixed acidity']
test['new_col2'] = test['free sulfur dioxide'] / test['total sulfur dioxide']
test['new_col3'] = test['volatile acidity'] + test['fixed acidity']

test

# scaler = StandardScaler()

# train[train.columns[2:-6]] = scaler.fit_transform(train[train.columns[2:-6]])
# train[train.columns[-3:]] = scaler.fit_transform(train[train.columns[-3:]])

scaler = MinMaxScaler()

train[train.columns[2:-6]] = scaler.fit_transform(train[train.columns[2:-6]])
test[test.columns[1:-6]] = scaler.transform(test[test.columns[1:-6]])
train[train.columns[-3:]] = scaler.fit_transform(train[train.columns[-3:]])
test[test.columns[-3:]] = scaler.fit_transform(test[test.columns[-3:]])

def data_preprocessing():
  
  train = pd.read_csv('/content/drive/MyDrive/와인1/train.csv')
  test = pd.read_csv('/content/drive/MyDrive/와인1/test.csv')
  submission = pd.read_csv('/content/drive/MyDrive/와인1/sample_submission.csv')

  train = train.append(train[train['quality'].isin([4,7,8])])
  train = train.append(train[train['quality'].isin([7])])

  train = pd.concat([train, pd.get_dummies(train['type'])],axis=1)
  test = pd.concat([test, pd.get_dummies(test['type'])],axis=1)

  train['new_col'] = train['volatile acidity'] / train['fixed acidity']
  train['new_col2'] = train['free sulfur dioxide'] / train['total sulfur dioxide']
  train['new_col3'] = train['volatile acidity'] + train['fixed acidity']

  print(train['quality'].value_counts().sort_index())

  
  return train,test,submission

def test_preprocessing(test):
  test['new_col'] = test['volatile acidity'] / test['fixed acidity']
  test['new_col2'] = test['free sulfur dioxide'] / test['total sulfur dioxide']
  test['new_col3'] = test['volatile acidity'] + test['fixed acidity']
  return test

def scaling(train,test):
  scaler = MinMaxScaler()

  train[train.columns[2:-6]] = scaler.fit_transform(train[train.columns[2:-6]])
  test[test.columns[1:-6]] = scaler.transform(test[test.columns[1:-6]])
  
  train[train.columns[-3:]] = scaler.fit_transform(train[train.columns[-3:]])
  test[test.columns[-3:]] = scaler.fit_transform(test[test.columns[-3:]])
  return train,test

data_preprocessing()

train

test

data_preprocessing()
test_preprocessing()
scaling()

features = train.columns[2:].drop(['type'])
# features = train.columns[2:].drop(['type','sulphates','total sulfur dioxide','residual sugar','free sulfur dioxide','citric acid','pH','fixed acidity'])
# features = train.columns[2:].drop(['type','total sulfur dioxide','pH'])
# features = train.columns[2:].drop(['type','new_col',	'new_col2'	,'new_col3'])
# features = train.columns[2:].drop(['type','white','red'])
features

X = train[features]
y = train['quality']

from sklearn.model_selection import StratifiedKFold
kfold = StratifiedKFold(n_splits=5,shuffle=True,random_state=42)

models = []
accs = []
for train_idx, valid_idx in kfold.split(X,y):
  X_train,X_valid = X.iloc[train_idx],X.iloc[valid_idx]
  y_train,y_valid = y.iloc[train_idx],y.iloc[valid_idx]

  model = RandomForestClassifier()

  model.fit(X_train,y_train)
  
  #추가
  models.append(model)

  y_pred = model.predict(X_valid)
  accs.append(ACC(y_valid,y_pred))
  make_plot()

  pred_ = pd.DataFrame(y_pred,y_valid).reset_index()
  pred_.columns = ['valid','pred']
  pred_['T/F'] = pred_['valid']==pred_['pred']
  print(pred_[pred_['T/F']==False].value_counts().sort_index())

train,test,submission = data_preprocessing()
test = test_preprocessing(test)
train,test = scaling(train,test)

features = train.columns[2:].drop(['type'])
# features = train.columns[2:].drop(['type','sulphates','total sulfur dioxide','residual sugar','free sulfur dioxide','citric acid','pH','fixed acidity'])
# features = train.columns[2:].drop(['type','total sulfur dioxide','pH'])
# features = train.columns[2:].drop(['type','new_col',	'new_col2'	,'new_col3'])
# features = train.columns[2:].drop(['type','white','red'])
features

test

X = train[features]
y = train['quality']

from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import ExtraTreesClassifier

models = []

rfc = RandomForestClassifier()

models.append(rfc)

gbc = GradientBoostingClassifier()

models.append(gbc)

etc = ExtraTreesClassifier()

models.append(etc)

models

grid_n_estimator = [100,150, 300]
grid_ratio = [.1, .25, .5, .75, 1.0]
grid_learn = [.01, .03, .05, .1, .25]
grid_max_depth = [2,3, 4, 6, 8, None]
grid_min_samples = [5, 10, .03, .05, .10]
grid_criterion = ['gini', 'entropy']
grid_bool = [True, False]
grid_seed = [0]

best_models = {}
params=[
    {
        #RandomForestClassifier - http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier
        'n_estimators': grid_n_estimator, #default=10
        'criterion': grid_criterion, #default=”gini”
        'max_depth': grid_max_depth, #default=None
        'oob_score': [True,False], #default=False -- 12/31/17 set to reduce runtime -- The best parameter for RandomForestClassifier is {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 100, 'oob_score': True, 'random_state': 0} with a runtime of 146.35 seconds.
        'random_state': grid_seed
    },
    {   
        #GradientBoostingClassifier - http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html#sklearn.ensemble.GradientBoostingClassifier
        #'loss': ['deviance', 'exponential'], #default=’deviance’
        'learning_rate': [0.1,0.05], #default=0.1 -- 12/31/17 set to reduce runtime -- The best parameter for GradientBoostingClassifier is {'learning_rate': 0.05, 'max_depth': 2, 'n_estimators': 300, 'random_state': 0} with a runtime of 264.45 seconds.
        'n_estimators': [100,300], #default=100 -- 12/31/17 set to reduce runtime -- The best parameter for GradientBoostingClassifier is {'learning_rate': 0.05, 'max_depth': 2, 'n_estimators': 300, 'random_state': 0} with a runtime of 264.45 seconds.
        #'criterion': ['friedman_mse', 'mse', 'mae'], #default=”friedman_mse”
        'max_depth': [2,3], #default=3   
        'random_state': grid_seed
    },
    {
      'n_estimators': grid_n_estimator, #default=10
      'criterion': grid_criterion, #default=”gini”
      'max_depth': [2,3, 4, None], #default=None
      'random_state': grid_seed  
    }
    ]

for i,model in enumerate(models):
  model = GridSearchCV(model,param_grid = params[i], cv=7, return_train_score = True, verbose=2)

  model.fit(X,y)

  best_models[i] = model.best_estimator_

best_models

pred0 = best_models[0].predict(test[features])
pred1 = best_models[1].predict(test[features])
pred2 = best_models[2].predict(test[features])
pred = pd.DataFrame({'pred0':pred0,'pred1':pred1,'pred2':pred2})
pred

pred['pred_hard'] = pred.mode(axis=1)[0].astype(int)
pred

pred0 = best_models[0].predict_proba(test[features])
pred1 = best_models[1].predict_proba(test[features])
pred2 = best_models[2].predict_proba(test[features])
pred_soft = pd.DataFrame(pred0+pred1+pred2/3)
pred_soft.head()

pred['pred_soft']= pd.DataFrame(np.argmax(np.array(pred_soft), axis=1))+3
pred

pred[pred['pred_hard']!=pred['pred_soft']]

submission['quality'] = pred['pred_hard']
submission.to_csv('submission_hard.csv',index=False)

submission['quality'] = pred['pred_soft']
submission.to_csv('submission_soft.csv',index=False)