# загрузим библиотеки и установим опции
 
from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns
 
import pickle
import numpy as np
import pandas as pd
from scipy.sparse import csr_matrix
from scipy.sparse import hstack
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score
from sklearn.linear_model import LogisticRegression
 
from sklearn.datasets import load_files
from sklearn.svm import LinearSVC
 
 
# загрузим обучающую и тестовую выборки
train_df = pd.read_csv('C:/Users/Kazzi/Desktop/mlcourse_open-master/data/train_sessions.csv',
                       index_col='session_id')
test_df = pd.read_csv('C:/Users/Kazzi/Desktop/mlcourse_open-master/data/test_sessions.csv',
                      index_col='session_id')
 
# приведем колонки time1, ..., time10 к временному формату
times = ['time%s' % i for i in range(1, 11)]
train_df[times] = train_df[times].apply(pd.to_datetime)
test_df[times] = test_df[times].apply(pd.to_datetime)
 
# отсортируем данные по времени
train_df = train_df.sort_values(by='time1')
 
# посмотрим на заголовок обучающей выборки
train_df.head()
 
# приведем колонки site1, ..., site10 к целочисленному формату и заменим пропуски нулями
sites = ['site%s' % i for i in range(1, 11)]
train_df[sites] = train_df[sites].fillna(0).astype('int')
test_df[sites] = test_df[sites].fillna(0).astype('int')
 
# загрузим словарик сайтов
with open(r"C:/Users/Kazzi/Desktop/mlcourse_open-master/data/site_dic.pkl", "rb") as input_file:
    site_dict = pickle.load(input_file)
 
# датафрейм словарика сайтов
sites_dict = pd.DataFrame(list(site_dict.keys()), index=list(site_dict.values()), columns=['site'])
print(u'всего сайтов:', sites_dict.shape[0])
sites_dict.head()
 
# топ-сайты в обучающей выборке
top_sites = pd.Series(train_df[sites].fillna(0).values.flatten()
                     ).value_counts().sort_values(ascending=False).head(5)
print(top_sites)
sites_dict.ix[top_sites.index]
 
 
time_df = pd.DataFrame(index=train_df.index)
time_df['target'] = train_df['target']
 
# найдем время начала и окончания сессии
time_df['min'] = train_df[times].min(axis=1)
time_df['max'] = train_df[times].max(axis=1)
 
# вычислим длительность сессии и переведем в секунды
time_df['seconds'] = (time_df['max'] - time_df['min']) / np.timedelta64(1, 's')
 
time_df.head()
# создадим отдельный датафрейм, где будем работать со временем
time_df = pd.DataFrame(index=train_df.index)
time_df['target'] = train_df['target']
​
# найдем время начала и окончания сессии
time_df['min'] = train_df[times].min(axis=1)
time_df['max'] = train_df[times].max(axis=1)
​
# вычислим длительность сессии и переведем в секунды
time_df['seconds'] = (time_df['max'] - time_df['min']) / np.timedelta64(1, 's')
​
time_df.head()
 
# наша целевая переменная
y_train = train_df['target']
 
# объединенная таблица исходных данных
full_df = pd.concat([train_df.drop('target', axis=1), test_df])
 
# индекс, по которому будем отделять обучающую выборку от тестовой
idx_split = train_df.shape[0]
 
full_df.corr()
 
# табличка с индексами посещенных сайтов в сессии
full_sites = full_df[sites]
full_sites.head()
 
# последовательность с индексами
sites_flatten = full_sites.values.flatten()
 
# искомая матрица
full_sites_sparse = csr_matrix(([1] * sites_flatten.shape[0],
                                sites_flatten,
                                range(0, sites_flatten.shape[0]  + 10, 10)))[:, 1:]
 
%%time
# выделим из объединенной выборки только обучающую (для которой есть ответы)
X_train = full_sites_sparse[:idx_split, :]
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
# функция для записи прогнозов в файл
def write_to_submission_file(predicted_labels, out_file,
                             target='target', index_label="session_id"):
    predicted_df = pd.DataFrame(predicted_labels,
                                index = np.arange(1, predicted_labels.shape[0] + 1),
                                columns=[target])
    predicted_df.to_csv(out_file, index_label=index_label)
 
# обучим модель на всей выборке
# random_state=17 для воспроизводимости
# параметр C=1 по умолчанию, но здесь мы его укажем явно
lr = LogisticRegression(C=1.0, random_state=17).fit(X_train, y_train)
 
# обучим модель на всей выборке
# random_state=17 для воспроизводимости
# параметр C=1 по умолчанию, но здесь мы его укажем явно
lr = LogisticRegression(C=1.0, random_state=17).fit(X_train, y_train)
 
def plot_grid_scores(grid, param_name):
    plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_train_score'],
        color='green', label='train')
    plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_test_score'],
        color='red', label='test')
    plt.legend();
 
visualize_coefficients(lr, site_dict)
 
 
full_new_feat = pd.DataFrame(index=full_df.index)
 
# добавим признак start_month
full_new_feat['start_month'] = full_df['time1'].apply(lambda ts: 100 * ts.year + ts.month)
# датафрейм для новых признаков
 
# рассчитаем количество сессий Элис по месяцам
tmp = full_new_feat.ix[:idx_split, 'start_month'].to_frame()
tmp['target'] = y_train
stm_vs_target = tmp.groupby('start_month')['target'].sum()
 
# вывод таблички
print(stm_vs_target)
 
 
# построим график
x_axis = stm_vs_target.index
y_axis = stm_vs_target.values
fig=plt.figure(figsize=(12, 8))
ax1=fig.add_subplot(111)
line1 = ax1.plot(y_axis,'ro',label='line1')
plt.xticks(range(len(y_axis)), x_axis)
ax1.set_ylabel('y values',fontsize=12)
lines = line1
labels = [l.get_label() for l in lines]
ax1.set_xlabel('ГГГГММ',fontsize=14)
ax1.set_ylabel('Кол-во сессий',fontsize=14)
plt.setp(ax1.get_xticklabels(), visible=True)
plt.suptitle(u'Количество сессий Элис по месяцам', y=1.0, fontsize=17)
fig.tight_layout()
fig.subplots_adjust(top=0.96,bottom=0.4)
plt.show() 
 
# добавим новый признак в разреженную матрицу
tmp = full_new_feat[['start_month']].as_matrix()
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], tmp[:idx_split,:]]))
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
# добавим новый стандартизированный признак в разреженную матрицу
tmp = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], tmp[:idx_split,:]]))
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
full_new_feat['start_hour'] = full_df['time1'].apply(lambda ts: ts.hour)
full_new_feat['morning'] = full_new_feat['start_hour'].apply(lambda hour: int(hour <= 11))
 
 
# scaled start_hour
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.957924006323 <---
 
# raw start_hour
tmp_raw = full_new_feat[['start_hour']].as_matrix()
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.919698464197
 
 
 
# scaled morning
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:],
                             tmp_raw[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.958430928728 <---
                         
# raw morning
tmp_raw = full_new_feat[['morning']].as_matrix()
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:],
                             tmp_raw[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.948665199943
 
 
# start_hour и morning
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.959149043641 <---
 
full_new_feat.corr()
 
# формируем обучающую выборку
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
 
# зафиксируем качество с параметрами по умолчанию
score_C_1 = get_auc_lr_valid(X_train, y_train)
print(score_C_1)
 
%%time
# набор возможных значений С
Cs = np.logspace(-3, 1, 10)
 
scores = []
    
for C in Cs:
    scores.append(get_auc_lr_valid(X_train, y_train, C=C))
 
plt.plot(Cs, scores, 'ro-')
plt.xscale('log')
plt.xlabel('C')
plt.ylabel('AUC-ROC')
plt.title('Подбор коэффициента регуляризации')
# горизонтальная линия -- качество модели с коэффициентом по умолчанию
plt.axhline(y=score_C_1, linewidth=.5, color = 'b', linestyle='dashed') 
plt.show()
 
# подготовим данные для обучения и теста
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
X_test = csr_matrix(hstack([full_sites_sparse[idx_split:,:], 
                            tmp_scaled[idx_split:,:]]))
 
# обучим модель на всей выборке с оптимальным коэффициентом регуляризации
lr = LogisticRegression(C=C, random_state=17).fit(X_train, y_train)