Применение методов анализа формальных понятий для нахождения зависимости между анкетными показателями клиентов и фактом дефолта по кредиту

COL2 = []

COL3 = []

COL4 = []

COL5 = []

COL6 = []

COL7 = []

COL8 = []

COL9 = []

COL10 = []

N_OF_ITER = []

ALPHA = []

SAMPLE_SIZES = []

def generate_grid(N_OF_ITER,ALPHA,SAMPLE_SIZES):

X = [2000]

Y = [0.001, 0.002,0.003, 0.004, 0.005]

Z = [1,2,3,4,5]

for x in X:

for y in Y:

for z in Z:

N_OF_ITER.append(x)

ALPHA.append(y)

SAMPLE_SIZES.append(z)

generate_grid(N_OF_ITER,ALPHA,SAMPLE_SIZES)

MODIFICATION = "concepts_"

# MODIFICATION = ""

# for dir_name in os.listdir():

# dir_name = dir_name.strip(MODIFICATION).split('_')

# if len(dir_name)==3 and str.isnumeric(dir_name[0]) and str.isnumeric(dir_name[2]):

# number_of_iterations = int(dir_name[0])

# alpha = float(dir_name[1])

# subsample_size = int(dir_name[2])

# # CONDITIONS. Что печатать?

# # if alpha >= 0.002 and alpha <= 0.005:

# if True:

# N_OF_ITER.append(number_of_iterations)

# ALPHA.append(alpha)

# SAMPLE_SIZES.append(subsample_size)

for number_of_iterations,alpha,subsample_size in zip(N_OF_ITER,ALPHA,SAMPLE_SIZES):

DIR_NAME = MODIFICATION+str(alpha)+'_'+str(subsample_size)

result = pd.DataFrame()

for NUMBER_OF_MINI_TEST in range(8):

FILE_NAME = str(NUMBER_OF_MINI_TEST)+".csv"

PATH = ".\\"+DIR_NAME+"\\"+FILE_NAME

result_mini_test = pd.read_csv(PATH, index_col=0)

result = pd.concat((result,result_mini_test))

y_true = result.y_true

num_of_unclassified = np.sum((result.NEG_VOTES == 0) & (result.POS_VOTES == 0))

# Вычитаем голоса

y_pred_diff = result.POS_VOTES*1 - result.NEG_VOTES*1

y_pred_diff.loc[(result.NEG_VOTES == 0) & (result.POS_VOTES == 0)] = 0 # У КОГО СЧЕТ 0:0, тех относим к классу 0

# y_pred_diff = 1 / (1 + np.exp(-y_pred_diff))

y_pred_diff = y_pred_diff - np.min(y_pred_diff)/(np.max(y_pred_diff)-np.min(y_pred_diff))

roc_auc_diff = sklearn.metrics.roc_auc_score(y_true,y_pred_diff)

# Доля голосов

y_pred_div = result.POS_VOTES*1/(result.POS_VOTES*1+result.NEG_VOTES*1)

y_pred_div.loc[(result.NEG_VOTES == 0) & (result.POS_VOTES == 0)] = 0 # У КОГО СЧЕТ 0:0, тех относим к классу 0

roc_auc_div = sklearn.metrics.roc_auc_score(y_true,y_pred_div)

COL1.append(number_of_iterations)

COL2.append(alpha)

COL3.append(subsample_size)

# COL4.append(roc_auc)

COL5.append(roc_auc_div)

COL6.append(num_of_unclassified)

COL7.append(roc_auc_diff)

# 'ROC-AUC':COL4

summary = pd.DataFrame({'number_of_iterations':COL1,'alpha':COL2,'subsample_size':COL3, 'roc_auc_div':COL5,'roc_auc_diff':COL7,'num_of_unclassified':COL6

})

pd.set_option('display.max_rows', 1000)

summary.set_index(['number_of_iterations','alpha','subsample_size'])

# ##### Classifying objects with missing data

# In[624]:

df_na = pd.read_csv('cs-training.csv', index_col=0)

df_na = df_na[df_na.MonthlyIncome.isnull()]

df_na.shape

# In[628]:

df_na_pos = df_na[df_na.SeriousDlqin2yrs == 1]

df_na_minus = df_na.drop(df_na_pos.index)

df_na_pos_test = df_na_pos.sample(frac=0.1, random_state=1)

df_na_neg_test = df_na_minus.sample(frac=0.1, random_state=1)

df_na_test = df_na_pos_test.append(df_na_neg_test)

# In[636]:

# df_na_test.to_csv('df_na_test.csv')

# In[643]:

df_na_test = pd.read_csv('df_na_test.csv', index_col=0)

y_na_true = df_na_test.SeriousDlqin2yrs

df_na_test = df_na_test.drop('SeriousDlqin2yrs', axis=1)

# In[843]:

df_na_test = pd.read_csv('cs-test.csv', index_col=0)

y_na_true = df_na_test.SeriousDlqin2yrs

df_na_test = df_na_test.drop('SeriousDlqin2yrs', axis=1)

ALPHA = [0.001]

SAMPLE_SIZES = [3]

N_OF_NEEDED_CONCEPTS = [2000]

for alpha in ALPHA:

for subsample_size in SAMPLE_SIZES:

for number_of_concepts in N_OF_NEEDED_CONCEPTS:

start_time = datetime.datetime.now()

print("PARAMS: ", number_of_concepts, alpha, subsample_size)

print("MINING PLUS (+) STARTED AT:", start_time.ctime())

DIR_NAME = "concepts_"+str(alpha)+'_'+str(subsample_size)

PATH = ".\\"+DIR_NAME+"\\"

positive_concepts_min = pd.read_csv(PATH+str(number_of_concepts)+'_'+"positive_concepts_min.csv",index_col=0).values

positive_concepts_max = pd.read_csv(PATH+str(number_of_concepts)+'_'+"positive_concepts_max.csv",index_col=0).values

negative_concepts_min = pd.read_csv(PATH+str(number_of_concepts)+'_'+"negative_concepts_min.csv",index_col=0).values

negative_concepts_max = pd.read_csv(PATH+str(number_of_concepts)+'_'+"negative_concepts_max.csv",index_col=0).values

positive_n_intersections_with_neg = pd.read_csv(PATH+str(number_of_concepts)+'_'+"positive_n_intersections_with_neg.csv",index_col=0, header=-1).values[:,0]

negative_n_intersections_with_pos = pd.read_csv(PATH+str(number_of_concepts)+'_'+"negative_n_intersections_with_neg.csv",index_col=0, header=-1).values[:,0]

NUMBER_OF_MINI_TEST = 0

mini_test_size = df_na_test.shape[0]//8

start_index = mini_test_size*NUMBER_OF_MINI_TEST

end_index = start_index+mini_test_size

mini_test_index = df_na_test.index[start_index:end_index]

NUMBER_OF_POS_VOTES = []

NUMBER_OF_NEG_VOTES = []

start_time = datetime.datetime.now()

for test_index in mini_test_index:

test_obj = df_na_test.loc[test_index].values

neg_itersections_with_all_pos = np.zeros(number_of_concepts)

pos_itersections_with_all_neg = np.zeros(number_of_concepts)

X_neg = X_neg_true[np.random.choice(X_neg_true.shape[0], size=X_pos.shape[0], replace=False)]

test_obj_max = test_obj.copy()

test_obj_max[np.isnan(test_obj_max)] = np.inf

test_obj_min = test_obj.copy()

test_obj_min[np.isnan(test_obj_min)] = -np.inf

premises_min = np.minimum(positive_concepts_min,test_obj_min)

premises_max = np.maximum(positive_concepts_max,test_obj_max)

premises = np.concatenate((premises_min, premises_max), axis=1)

pos_itersections_with_all_neg = np.apply_along_axis(lambda row: np.sum( ((row[:10] <= X_neg) & (X_neg <= row[10:])).all(axis=1) ), 1, premises)

premises_min = np.minimum(negative_concepts_min,test_obj_min)

premises_max = np.maximum(negative_concepts_max,test_obj_max)

premises = np.concatenate((premises_min, premises_max), axis=1)

neg_itersections_with_all_pos = np.apply_along_axis(lambda row: np.sum( ((row[:10] <= X_pos) & (X_pos <= row[10:])).all(axis=1) ), 1, premises)

NUMBER_OF_POS_VOTES.append(np.sum(pos_itersections_with_all_neg/X_neg.shape[0] <= alpha))

NUMBER_OF_NEG_VOTES.append(np.sum(neg_itersections_with_all_pos/X_pos.shape[0] <= alpha))

df_result = pd.DataFrame({'POS_VOTES':NUMBER_OF_POS_VOTES,'NEG_VOTES':NUMBER_OF_NEG_VOTES,'y_true':y_na_true[mini_test_index]}, index=mini_test_index)

FILE_NAME = 'na_'+str(NUMBER_OF_MINI_TEST)+".csv"

PATH = ".\\"+DIR_NAME+"\\"+FILE_NAME

df_result.to_csv(PATH)

print(datetime.datetime.now() - start_time)

print("ENDED AT:", datetime.datetime.now())

print("")

# In[34]:

COL1 = []

COL2 = []

COL3 = []

COL4 = []

COL5 = []

COL6 = []

COL7 = []

COL8 = []

COL9 = []

COL10 = []

N_OF_ITER = []

ALPHA = []

SAMPLE_SIZES = []

# def generate_grid(N_OF_ITER,ALPHA,SAMPLE_SIZES):

# X = [2000]

# Y = [0.001, 0.002,0.003, 0.004, 0.005]

# Z = [1,2,3,4,5]

# for x in X:

# for y in Y:

# for z in Z:

# N_OF_ITER.append(x)

# ALPHA.append(y)

# SAMPLE_SIZES.append(z)

# generate_grid(N_OF_ITER,ALPHA,SAMPLE_SIZES)

MODIFICATION = "concepts_"

# MODIFICATION = ""

for dir_name in os.listdir():

dir_name = dir_name.strip(MODIFICATION).split('_')

if len(dir_name)==3 and str.isnumeric(dir_name[0]) and str.isnumeric(dir_name[2]):

number_of_iterations = int(dir_name[0])

alpha = float(dir_name[1])

subsample_size = int(dir_name[2])

# CONDITIONS. Что печатать?

if alpha >= 0.002 and alpha <= 0.005:

# if True:

N_OF_ITER.append(number_of_iterations)

ALPHA.append(alpha)

SAMPLE_SIZES.append(subsample_size)

for number_of_iterations,alpha,subsample_size in zip(N_OF_ITER,ALPHA,SAMPLE_SIZES):

DIR_NAME = MODIFICATION+str(alpha)+'_'+str(subsample_size)

result = pd.DataFrame()

for NUMBER_OF_MINI_TEST in range(8):

FILE_NAME = "na_"+str(NUMBER_OF_MINI_TEST)+".csv"

PATH = ".\\"+DIR_NAME+"\\"+FILE_NAME

result_mini_test = pd.read_csv(PATH, index_col=0)

result = pd.concat((result,result_mini_test))

y_true = result.y_true

num_of_unclassified = np.sum((result.NEG_VOTES == 0) & (result.POS_VOTES == 0))

# Вычитаем голоса

y_pred_diff = result.POS_VOTES*1 - result.NEG_VOTES*1

y_pred_diff.loc[(result.NEG_VOTES == 0) & (result.POS_VOTES == 0)] = 0 # У КОГО СЧЕТ 0:0, тех относим к классу 0

# y_pred_diff = 1 / (1 + np.exp(-y_pred_diff))

y_pred_diff = y_pred_diff - np.min(y_pred_diff)/(np.max(y_pred_diff)-np.min(y_pred_diff))

roc_auc_diff = sklearn.metrics.roc_auc_score(y_true,y_pred_diff)

# Доля голосов

y_pred_div = result.POS_VOTES*1/(result.POS_VOTES*1+result.NEG_VOTES*1)

y_pred_div.loc[(result.NEG_VOTES == 0) & (result.POS_VOTES == 0)] = 0 # У КОГО СЧЕТ 0:0, тех относим к классу 0

roc_auc_div = sklearn.metrics.roc_auc_score(y_true,y_pred_div)

COL1.append(number_of_iterations)

COL2.append(alpha)

COL3.append(subsample_size)

# COL4.append(roc_auc)

COL5.append(roc_auc_div)

COL6.append(num_of_unclassified)

COL7.append(roc_auc_diff)

# 'ROC-AUC':COL4

summary = pd.DataFrame({'number_of_iterations':COL1,'alpha':COL2,'subsample_size':COL3, 'roc_auc_div':COL5,'roc_auc_diff':COL7,'num_of_unclassified':COL6

})

pd.set_option('display.max_rows', 1000)

summary.set_index(['number_of_iterations','alpha','subsample_size'])

# ### Logistic regression

# In[19]:

df_train = df.drop(df_test.index).drop('SeriousDlqin2yrs', axis=1)

y_train_true = y[df_train.index]

y_test_true = y[df_test.index]

# In[54]:

from sklearn import linear_model

from sklearn import metrics

X = df_train.values

for C in [10**i for i in range(-10,10)]:

LR = linear_model.LogisticRegression(C=C, penalty='l1')

LR.fit(X,y_train_true)

print("C=",C," ","L=L1",end="\t\t")

print("Train score",sklearn.metrics.roc_auc_score(y_train_true, LR.predict_proba(X)[:,1]), end="\t")

print("Test score",sklearn.metrics.roc_auc_score(y_test_true, LR.predict_proba(X_test)[:,1]))

for C in [10**i for i in range(-10,10)]:

LR = linear_model.LogisticRegression(C=C, penalty='l2')

LR.fit(X,y_train_true)

print("C=",C," ","L=L2",end="\t\t")

print("Train score",sklearn.metrics.roc_auc_score(y_train_true, LR.predict_proba(X)[:,1]), end="\t")

print("Test score",sklearn.metrics.roc_auc_score(y_test_true, LR.predict_proba(X_test)[:,1]))

# ### Random forest

# In[ ]:

from sklearn import ensemble

from sklearn import metrics

X = df_train.values

ensemble.RandomForestClassifier()

for n_of_est in [10,50,100,200,500,1000]:

RF = ensemble.RandomForestClassifier(n_estimators=n_of_est, n_jobs=8)

RF.fit(X,y_train_true)

print("n_estimators=",n_of_est,end="\t\t")

print("Train score",sklearn.metrics.roc_auc_score(y_train_true, RF.predict_proba(X)[:,1]), end="\t")

print("Test score",sklearn.metrics.roc_auc_score(y_test_true, RF.predict_proba(X_test)[:,1]))

# ### 5. Comparison of the results

# MLCA and Random forest showed comparable results: AUC_ROC = $~0.84$.

#

# It's much more than logistic regression: AUC_ROC = $~0.68$.

# MLCA with best parameters was applied to Kaggle's test dataset (more than 100k objects including objects with missing data). The result AUC_ROC was approximately the same 0.843510.

# In the future one can perform data cleaning and crossvalidation that probably improve the quality of the classifier.

Размещено на Allbest.ru