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

import pandas as pd
import numpy as np

campaign = pd.read_csv('gdrive/My Drive/customer_segments_predicting/customerGroups.csv', sep = ',')
campaign.head()

campaign.describe()

# Check the number of nans in df
sum(campaign.isna().sum())

campaign[['target']].value_counts()

campaign[['target']].value_counts()[1]/campaign[['target']].value_counts().sum()*100

# Get one hot encoding of columns target to use categorical label in prediction
# The prediction is to get the successful campaign of the first group
one_hot = pd.get_dummies(campaign['target'])

# Join the encoded df
campaign = campaign.join(one_hot)

# Filtering out columns other than group 1, target and encoded target
df_first_group = campaign.filter(regex = 'g1_|target|^[0-9]')

df_first_group

from sklearn.model_selection import train_test_split, cross_val_score

# Exclude g1_21 as the unknown when the campaign is launched
# X is the first group features
X = df_first_group.filter(regex = '^(?!g1_21)g1_') 

# y is the successful campaign of the first group
y = df_first_group.loc[:, df_first_group.columns == 1]

# Split the X and our target variable into training and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

from sklearn.tree import DecisionTreeClassifier

clf = DecisionTreeClassifier(max_depth = 5, random_state = 0)
clf.fit(X_train, y_train)
cross_val_score(clf, X, y, cv=10)

from sklearn.metrics import multilabel_confusion_matrix

clf_predictions = clf.predict(X_test)
multilabel_confusion_matrix(y_test, clf_predictions)

import seaborn as sns
%matplotlib inline

# Calculate the correlation matrix
correlation_train_set = X_train.corr()

# Plot the heatmap to visualise the correlation of the features
sns.heatmap(correlation_train_set, 
            xticklabels = correlation_train_set.columns,
            yticklabels = correlation_train_set.columns)

# Using preprocessing minmaxscaler to change the range of the feautres
from sklearn import preprocessing

def scale_values(X: pd.DataFrame) -> pd.DataFrame:
  """
  Scale features by minmaxscaler

  """
  x = X.values # Returns a numpy array
  min_max_scaler = preprocessing.MinMaxScaler()
  x_scaled = min_max_scaler.fit_transform(x)
  X_scaled = pd.DataFrame(x_scaled, columns = X.columns)

  return X_scaled

X_train = scale_values(X_train)

def drop_correlated_features(X_train: pd.DataFrame):
  corr_matrix = X_train.corr().abs()

  # Select upper_part trof correlation matrix
  upper_triangle = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))

  # Find features with correlation greater than 0.90
  features_to_drop = [column for column in upper_triangle.columns if any(upper_triangle[column] > 0.90)]

  # Drop features 
  X_train.drop(features_to_drop, axis = 1, inplace=True)

  return X_train, features_to_drop

X_train_scaled, features_to_drop = drop_correlated_features(X_train)

# Save dropped features for further API purposes
import json
with open('/content/gdrive/My Drive/customer_segments_predicting/features_to_drop.json', 'w') as output_json:
    json.dump(features_to_drop, output_json)

# Show selected features
X_train_scaled

# Get only selected features based on correlation values
list_of_columns = list(X_train_scaled.columns)

X_selected_features = X[X.columns.intersection(list_of_columns)]

X_selected_features

# Resample using only selected features
X_train, X_test, y_train, y_test = train_test_split(X_selected_features, y, test_size = 0.2, 
                                                    random_state = 42)

clf = DecisionTreeClassifier(max_depth = 5, random_state = 0)
clf.fit(X_train, y_train)
dtree_predictions = clf.predict(X_test)
multilabel_confusion_matrix(y_test, dtree_predictions)

# Get first and second group in different df
df_first_group = campaign.filter(regex = '^(?!g1_21)g1_')
df_second_group = campaign.filter(regex = '^(?!g2_21)g2_');
df_second_group.columns = df_first_group.columns

# Append second group to the first one
df_both_groups = df_first_group.append(df_second_group, ignore_index=True)

"""
Get dummy variable as the column of the first group success.
y is the successful campaign of the both group (our target in this approach)
Append second group target (campaign[2]) to the first one (campaign[1])
"""
y = campaign[1] 
y = y.append(campaign[2], ignore_index=True)
y.columns = 'y'
df_both_groups['y'] = y

df_both_groups

# Sample train and test chunks
X = df_both_groups.filter(regex = '^g1_')
y = df_both_groups.loc[:, df_both_groups.columns == 'y']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

# Minmaxscale on the train dataset
X_train = scale_values(X_train)

X_train, features_to_drop = drop_correlated_features(X_train)

X_train

# Create classifier for the second approach
clf = DecisionTreeClassifier(max_depth = 6, random_state = 0)
clf.fit(X_train, y_train)

X_scaled = scale_values(X)

# Get only rows with testset
X_test = X_scaled.iloc[X_test.index]

# Drop features 
X_test.drop(features_to_drop, axis=1, inplace=True)

clf_predictions = clf.predict(X_test)
multilabel_confusion_matrix(y_test, clf_predictions)

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import GradientBoostingClassifier

# Try another classifier: GradientBoosting with the GridSearchCV to find best params
gbc = GradientBoostingClassifier()
params = {'max_depth':[2, 3, 5, 7],
         'max_leaf_nodes': [3, 4, 5, 6, 7, 8],
         'random_state': [0]}
gs_gbc = GridSearchCV(gbc,
                      param_grid=params,
                      scoring = 'accuracy',
                      cv = 5)
gs_gbc.fit(X_train, y_train.values.ravel())
gs_gbc.score(X_train, y_train)

gs_gbc.best_params_

gbc = GradientBoostingClassifier(max_depth = 3, max_features = 'auto', 
                                 max_leaf_nodes = 4, random_state = 0)
gbc.fit(X_train, y_train)

X_scaled = scale_values(X)
X_test = X_scaled.iloc[X_test.index]

# Drop features 
X_test.drop(features_to_drop, axis = 1, inplace = True)

dtree_predictions = gbc.predict(X_test)
multilabel_confusion_matrix(y_test, dtree_predictions)

# X is the first and second group features
df_groups = campaign.filter(regex = '^(?!g1_21)g1_|g2_')
X = df_groups.filter(regex = '^(?!g2_21)')

# y is the successful variable of the first and second group
y = campaign[[1,2]]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

# For the training set get proper groups

def train_set_append_one_group_into_another(X_train: pd.DataFrame):
  """
  To the first group append second group, to store in the same columns as in the first group.
  This is the part for the training set.

  """

  g1_Xtrain = X_train.filter(regex = '^g1_')
  g2_Xtrain = X_train.filter(regex = '^g2_')
  g2_Xtrain.columns = g1_Xtrain.columns

  # To the first group append second group, to store in the same columns as in the first group
  g12_Xtrain = g1_Xtrain.append(g2_Xtrain, ignore_index = True)
  g12_Xtrain_minmax = scale_values(g12_Xtrain)

  # Drop features 
  g12_Xtrain_minmax.drop(features_to_drop, axis = 1, inplace = True)
  g12_Xtrain_minmax

  return g12_Xtrain_minmax, g12_Xtrain

g12_Xtrain_minmax, g12_Xtrain = train_set_append_one_group_into_another(X_train)

# Save dropped features for further API purposes
g12_Xtrain.to_json(r'/content/gdrive/My Drive/customer_segments_predicting/g12_Xtrain.json')

# To the first group append second group target, to store in the same columns as in the first group
y = y_train[1].append(y_train[2], ignore_index=True)

gbc = GradientBoostingClassifier(max_depth = 3, max_features = 'auto', 
                                 max_leaf_nodes = 4, random_state = 0)
gbc.fit(g12_Xtrain_minmax, y)

from sklearn.externals import joblib
# Export model to pickle
joblib.dump(clf, '/content/gdrive/My Drive/customer_segments_predicting/model_third.pkl', compress = 1)

def test_set_append_one_group_into_another(X_test: pd.DataFrame, g12_Xtrain: pd.DataFrame):
  """
  To the first group append second group, to store in the same columns as in the first group.
  This is the part for the test set.

  """
  g1_Xtest = X_test.filter(regex = '^g1_')
  g2_Xtest = X_test.filter(regex = '^g2_')
  g2_Xtest.columns = g1_Xtest.columns
  g12_Xtest = g1_Xtest.append(g2_Xtest, ignore_index = True)

  indexes = g12_Xtest.index.copy()

  # Add training set to make proper minmaxscaling
  g12_Xtest = g12_Xtest.append(g12_Xtrain, ignore_index = True)
  g12_Xtest_minmax = scale_values(g12_Xtest)

  # Drop rows from the training set
  g12_Xtest_minmax = g12_Xtest_minmax.iloc[indexes] 

  # Drop features 
  g12_Xtest_minmax.drop(features_to_drop, axis = 1, inplace = True)
  g12_Xtest_minmax

  return g12_Xtest_minmax

g12_Xtest_minmax =  test_set_append_one_group_into_another(X_test, g12_Xtrain)

# To the first group append second group target, to store in the same columns as in the first group
y = y_test[1].append(y_test[2], ignore_index = True)

gbc_predictions = gbc.predict(g12_Xtest_minmax)
multilabel_confusion_matrix(y, gbc_predictions)

prediction_probability = gbc.predict_proba(g12_Xtest_minmax)
prediction_probability = pd.DataFrame(prediction_probability)

# Get probability from the first group and the second for the same campaign 
prediction_probability.iloc[0::int(y.size/2), :]

def dividing_test_set_into_two_groups(prediction_probability: pd.DataFrame, y: pd.DataFrame):
  """
  Dividing the set into two group. As is in the original frame.

  """
  # Divide the appended test set into group 1 and 2

  group_1_prediction_result = prediction_probability.iloc[:int(y.size/2), :]
  group_2_prediction_result = prediction_probability.iloc[int(y.size/2):, :].reset_index()

  group_2_prediction_result.drop('index', axis = 1, inplace = True)
  group_2_prediction_result.columns=['g2_0', 'g2_1']
  
  joined_results = group_1_prediction_result.join(group_2_prediction_result)

  return joined_results

joined_results = dividing_test_set_into_two_groups(prediction_probability, y)

def prediction_probability_process(prediction_probability: pd.DataFrame,
                                   threshold: float) -> pd.DataFrame:
    """
    Get the target by the comparison of the probability for the first group and 
    the second. Additionally, the threshold has been used if the probability 
    is low. In this case, none of the target groups should be used for marketing purposes.
    """

    mask = [(prediction_probability[1] >= prediction_probability['g2_1']) & 
            (prediction_probability[1] > threshold),
            (prediction_probability[1] < prediction_probability['g2_1']) & 
            (prediction_probability['g2_1'] > threshold)]
    prediction_probability['label'] = np.select(mask, [1, 2], default=0)

    return prediction_probability

joined_results = prediction_probability_process(prediction_probability = joined_results, 
                                                   threshold = 0.45)

# Get the original label for target
y_target = campaign[['target']]

y_train, y_test = train_test_split(y_target, test_size = 0.2, random_state = 42)
multilabel_confusion_matrix(y_test, joined_results['label'], labels=[0, 1, 2])

# Copy the results from this approach, due to usage it in the forth approach
third_approach_y_test = joined_results['label'].copy()

from sklearn.metrics import accuracy_score, precision_score
accuracy_score(y_test, joined_results['label'])

def fourth_approach_train_preprocess(campaign: pd.DataFrame):
    """
    Due to the different scale in the g1_21 and g2_21 columns, the columns 
    should be scale separated. 

    """
    # X is the first and second group feature (unknown when the campaign start)
    X = campaign.filter(regex = '^g1_21|g2_21')

    # y is the successful variable of the first and second group
    y = campaign[[1, 2]]

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

    # Scale one column, then the second
    g1_Xtrain = X_train.filter(regex = '^g1_')
    g1_Xtrain_minmax = scale_values(g1_Xtrain)
    g1_Xtrain_minmax = pd.DataFrame(g1_Xtrain_minmax)

    g2_Xtrain = X_train.filter(regex = '^g2_')
    g2_Xtrain_minmax = scale_values(g2_Xtrain)
    g2_Xtrain_minmax = pd.DataFrame(g2_Xtrain_minmax).rename(columns={"g2_21": "g1_21"})

    # Append the second group feature into the first one
    g12_Xtrain_minmax = g1_Xtrain_minmax.append(g2_Xtrain_minmax, ignore_index=True)

    y = y_train[1].append(y_train[2], ignore_index=True)

    return X, X_train, X_test, y_train, y_test, g12_Xtrain_minmax, y

def fourth_approach_test_preprocess(X_test: pd.DataFrame,
                                    X: pd.DataFrame):
  """
  Due to the different scale in the g1_21 and g2_21 columns, the columns 
  should be scale separated. 

  """

  indexes = X_test.index
  #g12_Xtest_minmax = scale_values(X_test)
  g12_Xtest_minmax = scale_values(X)

  # Drop rows from the training set
  g12_Xtest_minmax = g12_Xtest_minmax.iloc[indexes]

  # Append g2_21 into g1_21
  g12_Xtest = g12_Xtest_minmax['g1_21'].append(g12_Xtest_minmax['g2_21'], ignore_index = True)
  g12_Xtest = pd.DataFrame(g12_Xtest, columns = ['g1_21'])

  y = y_test[1].append(y_test[2], ignore_index=True)

  return g12_Xtest, y

# Due to the different scale in the g1_21 and g2_21 columns, the columns should be scale separated. 
X, X_train, X_test, y_train, y_test, g12_Xtrain_minmax, y = fourth_approach_train_preprocess(campaign)

g12_Xtrain_minmax

gbc = GradientBoostingClassifier(random_state = 0)
gbc.fit(g12_Xtrain_minmax, y)
gbc.score(g12_Xtrain_minmax, y)

g12_Xtest, y = fourth_approach_test_preprocess(X_test, X)

# If the label is zero, then the campaign should be stopped.
gbc_predictions = gbc.predict(g12_Xtest)
multilabel_confusion_matrix(y, gbc_predictions)

def prediction_probability_fourth_approach_processing(prediction_probability: pd.DataFrame) -> pd.DataFrame:
    """
    Get the target by the comparison of the probability for the first group and 
    the second. Additionally, the threshold has been used if the probability 
    is low. In this case, none of the target groups should be used for marketing purposes.
    """
    mask = [(prediction_probability[1] >= prediction_probability['g2_0']), # Don't stop campaign
         (prediction_probability[1] < prediction_probability['g2_0'])] 

    prediction_probability['label'] = np.select(mask, [1, 0], default=0)

    return prediction_probability

prediction_probability = gbc.predict_proba(g12_Xtest)
prediction_probability = pd.DataFrame(prediction_probability)

joined_g_21 = dividing_test_set_into_two_groups(prediction_probability, y)
joined_g_21 = prediction_probability_fourth_approach_processing(joined_g_21)

prediction_probability

# y is the target variable
y = campaign['target']

y_train, y_test = train_test_split(y, test_size = 0.2, random_state = 42)

# Copy to results to use it in further comparison 
y_target = y_test.copy()
y_target_original = y_test.copy()

multilabel_confusion_matrix(y_test, joined_g_21['label'], labels=[0, 1])

def processing_y_target(y_target: pd.DataFrame, 
                        third_y_test: pd.DataFrame, 
                        joined_g_21: pd.DataFrame) -> pd.DataFrame:
  """
  Get the results from the third and forth approach, to stop campaigns that 
  might be unsuccessful. If the campaign is predicted as group 1 or 2, then
  the check is made to the classifier of the gX_21 params. 

  """

  y_target_results = pd.DataFrame(y_target.reset_index().drop('index', axis=1))

  y_target_results['third'] = third_y_test
  y_target_results['label'] = joined_g_21['label']

  mask = [((y_target_results['third'] == 1) | (y_target_results['third'] == 2) ) & 
          (y_target_results['label'] == 0), # Stop campaign
          (y_target_results['third'] == 1),
          (y_target_results['third'] == 2)] 
  y_target_results['label'] = np.select(mask, [0, 1, 2], default=0)

  return y_target_results

joined_g_21 = processing_y_target(y_target=y_target, 
                                  third_y_test=third_approach_y_test, 
                                  joined_g_21=joined_g_21)

multilabel_confusion_matrix(y_target_original, joined_g_21['label'], labels=[0, 1, 2])

accuracy_score(y_target_original, joined_g_21['label'])

precision_score(y_target_original, joined_g_21['label'], average='weighted')

# Trying to get better results by the LogisticRegression
from sklearn.linear_model import LogisticRegression

X, X_train, X_test, y_train, y_test, g12_Xtrain_minmax, y = fourth_approach_train_preprocess(campaign)

logreg = LogisticRegression()
params = {'class_weight': [{ 0:0.5, 1:0.8 }, { 0:0.3, 1:0.8 }, { 0:1.0, 1:0.8 }, 
                           { 0:1.2, 1:0.8 }, { 0:1.5, 1:0.8 }, { 0:1.8, 1:0.8 }, 
                           { 0:3, 1:0.8 }],
          'random_state': [0]}

# By using gridsearchcv, try to find best params       
gs_logreg = GridSearchCV(logreg,
                      param_grid = params,
                      scoring = 'precision',
                      cv = 5)
gs_logreg.fit(g12_Xtrain_minmax, y)
gs_logreg.score(g12_Xtrain_minmax, y)

gs_logreg.best_params_

logreg = LogisticRegression(class_weight = {0: 0.5, 1: 0.8}, random_state = 0)
logreg.fit(g12_Xtrain_minmax, y)

g12_Xtest, y = fourth_approach_test_preprocess(X_test, X)

logreg_predictions = logreg.predict(g12_Xtest)
multilabel_confusion_matrix(y, logreg_predictions)

prediction_probability = logreg.predict_proba(g12_Xtest)
prediction_probability = pd.DataFrame(prediction_probability)

joined_g_21 = dividing_test_set_into_two_groups(prediction_probability, y)
joined_g_21 = prediction_probability_fourth_approach_processing(joined_g_21)

joined_g_21 = processing_y_target(y_target=y_target, 
                                  third_y_test=third_approach_y_test, 
                                  joined_g_21=joined_g_21)

multilabel_confusion_matrix(y_target_original, joined_g_21['label'], labels=[0, 1, 2])

accuracy_score(y_target_original, joined_g_21['label'])

precision_score(y_target_original, joined_g_21['label'], average='weighted')

# Trying to get better results by the KNeighborsClassifier
from sklearn.neighbors import KNeighborsClassifier

X, X_train, X_test, y_train, y_test, g12_Xtrain_minmax, y = fourth_approach_train_preprocess(campaign)

knn = KNeighborsClassifier(20)
knn.fit(g12_Xtrain_minmax, y)

g12_Xtest, y = fourth_approach_test_preprocess(X_test, X)

knn_predictions = knn.predict(g12_Xtest)
multilabel_confusion_matrix(y, knn_predictions)

prediction_probability = knn.predict_proba(g12_Xtest)
prediction_probability = pd.DataFrame(prediction_probability)

joined_g_21 = dividing_test_set_into_two_groups(prediction_probability, y)
joined_g_21 = prediction_probability_fourth_approach_processing(joined_g_21)

joined_g_21 = processing_y_target(y_target=y_target, 
                                  third_y_test=third_approach_y_test, 
                                  joined_g_21=joined_g_21)

multilabel_confusion_matrix(y_target, third_approach_y_test, labels=[0, 1, 2])

accuracy_score(y_target, joined_g_21['label'])

precision_score(y_target, joined_g_21['label'], average='weighted')

# X is the difference between first and second group feature
X = campaign.filter(regex = '^g1_21|g2_21')

# y is the target variable
X = campaign.filter(regex = '^(?!c_28)c_')
y = campaign[['target']]

c_Xtrain, c_Xtest, c_ytrain, c_ytest = train_test_split(X, y, test_size = 0.2, random_state = 42)

# c_ parameters process
c_Xtrain_minmax = scale_values(c_Xtrain)
c_Xtrain_minmax, features_to_drop_c = drop_correlated_features(c_Xtrain_minmax)

c_Xtrain_minmax.describe()

# For the test set process to drop redundant columns
indexes = c_Xtest.index

# Add training set to the test, to make better scaling
c_test = c_Xtest.append(c_Xtrain, ignore_index = True)
c_Xtest_minmax = scale_values(c_test)

# Drop rows from the training set
c_Xtest_minmax = c_Xtest_minmax.iloc[indexes] 

# Drop features 
c_Xtest_minmax.drop(features_to_drop_c, axis = 1, inplace = True)

c_Xtest_minmax

df_groups = campaign.filter(regex = '^(?!g1_21)g1_|g2_')

# X is the first and second group features
X = df_groups.filter(regex = '^(?!g2_21)')

# y is the target variable
y = campaign['target']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

# For the training set get proper groups as the one of the column in the dataframe
# to use it in modeling as the one of the feature
g1_Xtrain = X_train.filter(regex = '^g1_')
g1_Xtrain['group'] = 1
g2_Xtrain = X_train.filter(regex = '^g2_')
g2_Xtrain['group'] = 2
g2_Xtrain.columns = g1_Xtrain.columns
g12_Xtrain = g1_Xtrain.append(g2_Xtrain, ignore_index = True)

# Scale the value other for other than group column
g12_Xtrain_without_groups = g12_Xtrain.loc[:, g12_Xtrain.columns != 'group']
g12_Xtrain_without_groups_minmax = scale_values(g12_Xtrain_without_groups)

# Drop features by the correlation as in the previous approaches
g12_Xtrain_without_groups_minmax.drop(features_to_drop, axis = 1, inplace = True)
g12_Xtrain_without_groups_minmax['group'] = g12_Xtrain['group']

c_Xtest_minmax_appended = c_Xtrain_minmax.append(c_Xtrain_minmax, ignore_index = True)
y_train_appended=y_train.append(y_train, ignore_index = True)

result = pd.concat([g12_Xtrain_without_groups_minmax, c_Xtest_minmax_appended], axis = 1)
result

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import GradientBoostingClassifier

# Try GradientBoosting with the GridSearchCV to find best params
gbc = GradientBoostingClassifier()
params = {'max_depth':[3, 5, 7],
         'max_leaf_nodes': [3, 5, 7, 8],
         'random_state': [0]}

gs_gbc = GridSearchCV(gbc,
                      param_grid=params,
                      scoring = 'accuracy',
                      cv = 5)
gs_gbc.fit(result, y_train_appended)
gs_gbc.score(result, y_train_appended)

gs_gbc.best_params_

import sklearn.metrics

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import GradientBoostingClassifier

# Try GradientBoosting with the GridSearchCV to find best params
gbc = GradientBoostingClassifier()
params = {'max_depth':[3, 5, 7],
         'max_leaf_nodes': [3, 5, 7, 8],
         'random_state': [0]}

scorer = sklearn.metrics.make_scorer(sklearn.metrics.f1_score, average = 'weighted')

gs_gbc = GridSearchCV(gbc,
                      param_grid=params,
                      scoring = scorer,
                      cv = 5)
gs_gbc.fit(result, y_train_appended)
gs_gbc.score(result, y_train_appended)

from sklearn.pipeline import Pipeline

gbc = GradientBoostingClassifier()
params = {'model__max_depth': [7],
          'model__max_leaf_nodes': [8],
          'model__random_state': [0]}

pipe = Pipeline([
    ('model', gbc)])
pipe.fit(result, y_train_appended)
pipe.score(result, y_train_appended)

from sklearn.externals import joblib
# Export model to pickle
joblib.dump(pipe, '/content/gdrive/My Drive/customer_segments_predicting/model.pkl', compress = 1)

dtree_predictions = pipe.predict(result)
multilabel_confusion_matrix(y_train_appended, dtree_predictions)

# For the test set get proper groups as the one of the column in the dataframe
g1_Xtest = X_test.filter(regex = '^g1_')
g1_Xtest['group'] = 1
g2_Xtest = X_test.filter(regex = '^g2_')
g2_Xtest['group'] = 2
g2_Xtest.columns = g1_Xtest.columns
g12_Xtest = g1_Xtest.append(g2_Xtest, ignore_index = True)

# Scale the value other for other than group column
g12_Xtest_without_groups = g12_Xtest.loc[:, g12_Xtest.columns != 'group']
g12_Xtest_without_groups_minmax = scale_values(g12_Xtest_without_groups)

# Drop features 
g12_Xtest_without_groups_minmax.drop(features_to_drop, axis = 1, inplace = True)
g12_Xtest_without_groups_minmax['group'] = g12_Xtest['group']

c_Xtest_minmax_appended = c_Xtest_minmax.append(c_Xtest_minmax, ignore_index = True)
y_test_extended=y_test.append(y_test, ignore_index = True)

result = pd.concat([g12_Xtest_without_groups_minmax, c_Xtest_minmax_appended], axis = 1)

result

def divide_into_groups(first_half: bool, 
                       y_test_extended: pd.DataFrame,
                       result: pd.DataFrame) -> pd.DataFrame:
  """
  Divide into 2 group (g1 and g2). If first_half==True, that means the g1 group is
  processing

  """
  if first_half == True:
    half_result = result[:int(len(result)/2)]
    y_test_extended = y_test_extended[:int(len(result)/2)]
  else:
    half_result = result[int(len(result)/2):]
    y_test_extended = y_test_extended[int(len(result)/2):]

  return half_result, y_test_extended