├── .gitignore
├── utils
    ├── misc.py
    ├── deep_learning.py
    ├── data.py
    └── measuring_performance.py
├── 01_data_splitting.ipynb
├── 03_creating_xlearn_dataset.ipynb
├── 05_creating_deepctr_dataset.ipynb
├── 02_data_preprocessing.ipynb
└── 06_training_deepctr_model.ipynb


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | .ipynb_checkpoints/
3 | *.DS_Store
4 | utils/__pycache__/
5 | logs/
6 | models/
7 | 


--------------------------------------------------------------------------------
/utils/misc.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | import time
 3 | from contextlib import contextmanager
 4 | 
 5 | 
 6 | def dump_pickle(file_path, obj):
 7 |     with open(file_path, 'wb') as f:
 8 |         pickle.dump(obj, f)
 9 |         
10 |         
11 | def load_pickle(file_path):
12 |     with open(file_path, 'rb') as f:
13 |         obj = pickle.load(f)
14 |     return obj
15 |         
16 | 
17 | @contextmanager
18 | def get_elapsed_time(format_string='Elapsed time: %d sec', verbose=True):
19 |     start_time = time.perf_counter()
20 |     yield
21 |     elapsed_time = time.perf_counter() - start_time
22 |     if verbose:
23 |         print(format_string % elapsed_time)
24 | 


--------------------------------------------------------------------------------
/utils/deep_learning.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import tensorflow as tf
 3 | from tensorflow.python.client import device_lib
 4 | 
 5 | 
 6 | def _from_tfrecord(serialized, features, target_name, key_names):
 7 |     example = tf.io.parse_single_example(serialized=serialized, features=features)
 8 |     if key_names is not None:
 9 |         for key_name in key_names:
10 |             _ = example.pop(key_name, None)
11 |     if target_name is not None:
12 |         target = example.pop(target_name, None)
13 |         return example, target
14 |     else:
15 |         return example
16 | 
17 | 
18 | def extract_dataset(file_paths, compression_type=None, shuffle_buffer_size=1024, is_training=True):
19 |     files = tf.data.Dataset.list_files(file_paths, shuffle=False)
20 |     if is_training:
21 |         dataset = files.interleave(
22 |             lambda file: tf.data.TFRecordDataset(file, compression_type=compression_type),
23 |             num_parallel_calls=tf.data.experimental.AUTOTUNE).shuffle(shuffle_buffer_size, seed=42)
24 |     else:
25 |         dataset = tf.data.TFRecordDataset(files, compression_type=compression_type)
26 |     return dataset
27 | 
28 | 
29 | def transform_dataset(dataset, num_feature_names, cat_feature_names, target_name=None, key_names=None):
30 |     features = dict()
31 |     if key_names is not None:
32 |         for key_name in key_names:
33 |             features[key_name] = tf.io.FixedLenFeature([], tf.string)
34 |     if target_name is not None:
35 |         features[target_name] = tf.io.FixedLenFeature([], tf.int64)
36 |     for feature in num_feature_names:
37 |         features[feature] = tf.io.FixedLenFeature([], tf.float32)
38 |     for feature in cat_feature_names:
39 |         features[feature] = tf.io.FixedLenFeature([], tf.int64)
40 |     dataset = dataset.map(lambda serialized: _from_tfrecord(
41 |         serialized=serialized, features=features, target_name=target_name, key_names=key_names),
42 |                           num_parallel_calls=tf.data.experimental.AUTOTUNE)
43 |     return dataset
44 | 
45 | 
46 | def load_dataset(dataset, batch_size=32, is_training=True):
47 |     dataset = dataset.batch(batch_size).prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
48 |     if is_training:
49 |         return dataset.repeat()
50 |     else:
51 |         return dataset
52 | 
53 | 
54 | def get_available_gpus():
55 |     local_device_protos = device_lib.list_local_devices()
56 |     return [x.name for x in local_device_protos if x.device_type == 'GPU']
57 | 
58 | 
59 | def get_n_examples(dataset):
60 |     n_examples = 0
61 |     for batch in dataset.take(-1):
62 |         shape = list(batch[0].values())[0].shape
63 |         if len(shape) == 0:
64 |             n_examples += 1
65 |         else:
66 |             n_examples += shape[0]
67 |     return n_examples
68 | 
69 | 
70 | def get_n_steps(total_size, batch_size):
71 |     n_steps = total_size // batch_size
72 |     if total_size % batch_size > 0:
73 |         n_steps += 1
74 |     return int(n_steps)
75 | 
76 | 
77 | # This function is not yet checked whether it is thread-safe or not.
78 | def get_target(dataset):
79 |     target = np.array([])
80 |     for batch in dataset.take(-1):
81 |         target = np.concatenate([target, batch[1].numpy()])
82 |     return target
83 | 


--------------------------------------------------------------------------------
/utils/data.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | import tensorflow as tf
 3 | 
 4 | 
 5 | def _hash_str(string, n_bins):
 6 |     return int(hashlib.md5(string.encode('utf8')).hexdigest(), 16) % (n_bins - 1) + 1
 7 | 
 8 | 
 9 | def _get_feature_to_index(num_feature_names, cat_feature_names, n_categories, use_field):
10 |     if use_field:
11 |         feature_to_index = {feature: i for i, feature in enumerate(num_feature_names | cat_feature_names)}
12 |     else:
13 |         feature_to_index = {feature: i for i, feature in enumerate(num_feature_names)}
14 |         j = 0
15 |         for feature in cat_feature_names:
16 |             for label in range(n_categories[feature]):
17 |                 feature_to_index['_'.join([feature, str(label)])] = len(num_feature_names) + j
18 |                 j += 1
19 |     return feature_to_index
20 | 
21 | 
22 | def dump_libsvm_file(X, y, file, num_feature_names, cat_feature_names, n_categories, use_field=False, decimals=8,
23 |                      use_hash=False, n_bins=1e6):
24 |     feature_to_index = _get_feature_to_index(num_feature_names, cat_feature_names, n_categories, use_field)
25 |     with open(file, 'w') as f:
26 |         for i, row in X.iterrows():
27 |             if y is not None:
28 |                 serialized_row = str(y.loc[i])
29 |             else:
30 |                 serialized_row = ''
31 |             for feature in num_feature_names:
32 |                 index = str(feature_to_index[feature])
33 |                 field = ''.join([index, ':']) if use_field else ''
34 |                 serialized_row = ''.join(
35 |                     [serialized_row, ' ', index, ':', field, str(round(row[feature], decimals))])
36 |             for feature in cat_feature_names:
37 |                 if use_field:
38 |                     field = feature_to_index[feature]
39 |                     index = int(row[feature])
40 |                     index = _hash_str(str(index), n_bins) if use_hash and n_categories[feature] > n_bins else index
41 |                     serialized_row = ''.join([serialized_row, ' ', str(field), ':', str(index), ':1'])
42 |                 else:
43 |                     index = int(row[feature])
44 |                     index = _hash_str(str(index), n_bins) if use_hash and n_categories[feature] > n_bins else index
45 |                     index = feature_to_index['_'.join([feature, str(index)])]
46 |                     serialized_row = ''.join([serialized_row, ' ', str(index), ':1'])
47 |             f.write(serialized_row.lstrip() + '\n')
48 | 
49 | 
50 | def _bytes_feature(value):
51 |     return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
52 | 
53 | 
54 | def _float_feature(value):
55 |     return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))
56 | 
57 | 
58 | def _int64_feature(value):
59 |     return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
60 | 
61 | 
62 | def _serialize_example(feature):
63 |     example_proto = tf.train.Example(features=tf.train.Features(feature=feature))
64 |     return example_proto.SerializeToString()
65 | 
66 | 
67 | def dump_tfrecord_file(X, y, file, num_feature_names, cat_feature_names, target_name=None, key_names=None,
68 |                        decimals=8, compression_type=None):
69 |     options = tf.io.TFRecordOptions(compression_type=compression_type)
70 |     with tf.io.TFRecordWriter(path=file, options=options) as writer:
71 |         serialized_row = dict()
72 |         for i, row in X.iterrows():
73 |             if key_names is not None:
74 |                 for key_name in key_names:
75 |                     serialized_row[key_name] = _bytes_feature(row[key_name])
76 |             if y is not None:
77 |                 serialized_row[target_name] = _int64_feature(y.loc[i])
78 |             for feature in num_feature_names:
79 |                 serialized_row[feature] = _float_feature(round(row[feature], decimals))
80 |             for feature in cat_feature_names:
81 |                 serialized_row[feature] = _int64_feature(int(row[feature]))
82 |             writer.write(_serialize_example(serialized_row))
83 | 


--------------------------------------------------------------------------------
/utils/measuring_performance.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import matplotlib.pyplot as plt
  3 | import seaborn as sns
  4 | from sklearn.calibration import calibration_curve
  5 | from sklearn.metrics import (average_precision_score, confusion_matrix, log_loss, precision_recall_curve,
  6 |                              roc_auc_score, roc_curve)
  7 | plt.style.use('seaborn')
  8 | 
  9 | 
 10 | def get_norm_entropy(y_true, y_score, eps=1e-08):
 11 |     p = y_true.mean()
 12 |     y_score = np.where(y_score < eps, eps, y_score)
 13 |     y_score = np.where(y_score > 1.0 - eps, 1.0 - eps, y_score)
 14 |     return log_loss(y_true, y_score) / (-1.0 * (p * np.log(p) + (1.0 - p) * np.log(1.0 - p)))
 15 | 
 16 | 
 17 | def get_threshold_at_precision(y_true, y_score, precision):
 18 |     sorted_index = (-1.0 * y_score).argsort()
 19 |     precisions = y_true[sorted_index].cumsum() / (np.arange(y_true.shape[0]) + 1)
 20 |     return y_score[sorted_index][(precisions > precision).sum()]
 21 | 
 22 | 
 23 | def get_y_pred(y_score, threshold=0.5):
 24 |     return np.where(y_score >= threshold, 1, 0)
 25 | 
 26 | 
 27 | def plot_class_density(y_true, y_score, threshold=0.5, class_names=('0', '1')):
 28 |     fig, ax = plt.subplots(figsize=(6, 4))
 29 |     sns.kdeplot(y_score[y_true.astype('int') == 1], shade=True, linewidth=0.8, label=class_names[1], ax=ax)
 30 |     sns.kdeplot(y_score[y_true.astype('int') == 0], shade=True, linewidth=0.8, label=class_names[0], ax=ax)
 31 |     ax.axvline(x=threshold, color='black', linestyle='--', linewidth=1)
 32 |     ax.set_xlabel('Score')
 33 |     ax.legend(title='Class', loc='best')
 34 |     
 35 |     
 36 | def plot_calibration_curve(y_true, y_score):
 37 |     fig = plt.figure(figsize=(6, 6))
 38 |     ax = plt.subplot2grid((3, 1), (0, 0), rowspan=2)
 39 |     fraction_of_positives, mean_predicted_value = calibration_curve(y_true, y_score, n_bins=20)
 40 |     ax.plot(mean_predicted_value, fraction_of_positives, color='mediumblue', marker='s', label='Model', linewidth=1.0)
 41 |     ax.plot([0.0, 1.0], [0.0, 1.0], color='orange', linestyle='--', label='Perfectly Calibrated', linewidth=0.8)
 42 |     ax.legend(loc='best')
 43 |     ax.set_title('Calibration Plot (Reliability Curve)', fontsize=12, fontweight='bold')
 44 |     ax.set_xlabel('Mean Predicted Value')
 45 |     ax.set_ylabel('Fraction of Positives')
 46 |     ax.set_xlim([-0.05, 1.05])
 47 |     ax.set_ylim([-0.05, 1.05])
 48 |     
 49 |     
 50 | def plot_confusion_matrix(y_true, y_pred, normalize=False, class_names=('0', '1')):
 51 |     conf_mat = confusion_matrix(y_true, y_pred)
 52 |     fig, ax = plt.subplots(figsize=(4, 4))
 53 |     fmt = 'd'
 54 |     if normalize:        
 55 |         conf_mat = conf_mat / conf_mat.sum(axis=1)[:, np.newaxis]
 56 |         fmt = '.2%'
 57 |     sns.heatmap(conf_mat, cmap='coolwarm', annot=True, fmt=fmt, linewidths=0.5, square=True,
 58 |                 xticklabels=class_names, yticklabels=class_names, ax=ax)
 59 |     ax.set_xlabel('Predicted Class')
 60 |     ax.set_ylabel('Actual Class')
 61 |     ax.set_title('Confusion Matrix')
 62 |     return conf_mat
 63 | 
 64 | 
 65 | def plot_lift_curve(y_true, y_score):
 66 |     tested_sample_percent = (np.arange(len(y_true)) + 1) / len(y_true)
 67 |     found_sample_percent = y_true[(-1.0 * y_score).argsort()].cumsum() / y_true.sum()
 68 |     fig, ax = plt.subplots(figsize=(6, 4))
 69 |     ax.plot(tested_sample_percent, found_sample_percent, color='mediumblue', label='Lift Curve', linewidth=1.0)
 70 |     ax.fill_between([0.0, y_true.sum() / (len(y_true)), 1.0], [0.0, 1.0, 1.0], [0.0, y_true.sum() / (len(y_true)), 1.0], 
 71 |                     alpha=0.3, color='lightsteelblue')
 72 |     ax.set_xlabel('% Samples Tested')
 73 |     ax.set_ylabel('% Samples Found')
 74 |     ax.legend(loc='best')
 75 |     ax.set_title('Lift Chart', fontsize=12, fontweight='bold')
 76 |     ax.set_xlim([-0.01, 1.01])
 77 |     ax.set_ylim([-0.01, 1.01])
 78 | 
 79 | 
 80 | def plot_pr_curve(y_true, y_score):
 81 |     precision, recall, thresholds = precision_recall_curve(y_true, y_score)
 82 |     auprc = average_precision_score(y_true, y_score)
 83 |     fig, ax = plt.subplots(figsize=(6, 4))
 84 |     ax.plot(recall, precision, color='mediumblue', linewidth=1.0, label='PR Curve (AUPRC: {0:0.4%})'.format(auprc))
 85 |     ax.fill_between(recall, precision, step='mid', alpha=0.3, color='lightsteelblue')
 86 |     ax.set_xlabel('Recall')
 87 |     ax.set_ylabel('Precision')
 88 |     ax.legend(loc='best')
 89 |     ax.set_title('Precision - Recall', fontsize=12, fontweight='bold')
 90 |     ax.set_xlim([-0.01, 1.01])
 91 |     ax.set_ylim([0, 1.01])
 92 |     return auprc
 93 | 
 94 | 
 95 | def plot_roc_curve(y_true, y_score):
 96 |     fpr, tpr, thresholds = roc_curve(y_true, y_score)
 97 |     auroc = roc_auc_score(y_true, y_score)
 98 |     fig, ax = plt.subplots(figsize=(6, 4))
 99 |     ax.plot(fpr, tpr, color='mediumblue', linewidth=1.0, label='ROC Curve (AUROC: {0:0.4%})'.format(auroc))
100 |     ax.plot([0.0, 1.0], [0.0, 1.0], color='orange', linestyle='--', linewidth=0.8)
101 |     ax.set_xlabel('False Positive Rate')
102 |     ax.set_ylabel('True Positive Rate')
103 |     ax.legend(loc='best')
104 |     ax.set_title('Receiver Operating Characteristic', fontsize=12, fontweight='bold')
105 |     ax.set_xlim([-0.01, 1.01])
106 |     ax.set_ylim([0, 1.01])
107 |     return auroc
108 | 


--------------------------------------------------------------------------------
/01_data_splitting.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "%load_ext autoreload\n",
 10 |     "%autoreload 2"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "metadata": {},
 17 |    "outputs": [],
 18 |    "source": [
 19 |     "import gc\n",
 20 |     "import os\n",
 21 |     "import pandas as pd\n",
 22 |     "from utils.misc import *"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "markdown",
 27 |    "metadata": {},
 28 |    "source": [
 29 |     "The dataset can be downloaded from https://labs.criteo.com/2014/02/download-kaggle-display-advertising-challenge-dataset."
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 3,
 35 |    "metadata": {},
 36 |    "outputs": [],
 37 |    "source": [
 38 |     "DATA_DIR = os.path.abspath('../../Data/display_advertising_challenge')\n",
 39 |     "old_data_dir = os.path.join(DATA_DIR, 'dac')\n",
 40 |     "new_data_dir = os.path.join(DATA_DIR, 'processed')\n",
 41 |     "\n",
 42 |     "if not os.path.exists(new_data_dir):\n",
 43 |     "    os.makedirs(new_data_dir)"
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "code",
 48 |    "execution_count": 4,
 49 |    "metadata": {},
 50 |    "outputs": [],
 51 |    "source": [
 52 |     "column_names = pd.Index(['label'] + ['I%d' % (i + 1) for i in range(13)] + ['C%d' % (i + 1) for i in range(26)])"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 5,
 58 |    "metadata": {},
 59 |    "outputs": [
 60 |     {
 61 |      "name": "stdout",
 62 |      "output_type": "stream",
 63 |      "text": [
 64 |       "Elapsed time: 1357 sec\n"
 65 |      ]
 66 |     }
 67 |    ],
 68 |    "source": [
 69 |     "with get_elapsed_time():\n",
 70 |     "    df_train = pd.read_csv(os.path.join(old_data_dir, 'train.txt'), sep='\\t', names=column_names)\n",
 71 |     "    df_train.to_pickle(os.path.join(new_data_dir, 'df_train+valid+test.pkl'))"
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "code",
 76 |    "execution_count": 6,
 77 |    "metadata": {},
 78 |    "outputs": [
 79 |     {
 80 |      "name": "stdout",
 81 |      "output_type": "stream",
 82 |      "text": [
 83 |       "# of obs in train set: 45840617\n"
 84 |      ]
 85 |     }
 86 |    ],
 87 |    "source": [
 88 |     "print('# of obs in train set:', df_train.shape[0])"
 89 |    ]
 90 |   },
 91 |   {
 92 |    "cell_type": "code",
 93 |    "execution_count": 7,
 94 |    "metadata": {},
 95 |    "outputs": [],
 96 |    "source": [
 97 |     "test_size = 0.2\n",
 98 |     "split_index = round(df_train.shape[0] * test_size)\n",
 99 |     "df_train, df_test = df_train[:-split_index], df_train[-split_index:]"
100 |    ]
101 |   },
102 |   {
103 |    "cell_type": "code",
104 |    "execution_count": 8,
105 |    "metadata": {},
106 |    "outputs": [
107 |     {
108 |      "name": "stdout",
109 |      "output_type": "stream",
110 |      "text": [
111 |       "Elapsed time: 711 sec\n"
112 |      ]
113 |     }
114 |    ],
115 |    "source": [
116 |     "with get_elapsed_time():\n",
117 |     "    df_train.to_pickle(os.path.join(new_data_dir, 'df_train+valid.pkl'))\n",
118 |     "    df_test.to_pickle(os.path.join(new_data_dir, 'df_test.pkl'))"
119 |    ]
120 |   },
121 |   {
122 |    "cell_type": "code",
123 |    "execution_count": 9,
124 |    "metadata": {},
125 |    "outputs": [
126 |     {
127 |      "name": "stdout",
128 |      "output_type": "stream",
129 |      "text": [
130 |       "# of obs in train set: 36672494 \n",
131 |       "# of obs in test set: 9168123\n"
132 |      ]
133 |     }
134 |    ],
135 |    "source": [
136 |     "print('# of obs in train set:', df_train.shape[0], '\\n# of obs in test set:', df_test.shape[0])"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 10,
142 |    "metadata": {},
143 |    "outputs": [],
144 |    "source": [
145 |     "valid_size = 0.2\n",
146 |     "split_index = round(df_train.shape[0] * valid_size)\n",
147 |     "df_train, df_valid = df_train[:-split_index], df_train[-split_index:]"
148 |    ]
149 |   },
150 |   {
151 |    "cell_type": "code",
152 |    "execution_count": 11,
153 |    "metadata": {},
154 |    "outputs": [
155 |     {
156 |      "name": "stdout",
157 |      "output_type": "stream",
158 |      "text": [
159 |       "Elapsed time: 507 sec\n"
160 |      ]
161 |     }
162 |    ],
163 |    "source": [
164 |     "with get_elapsed_time():\n",
165 |     "    df_train.to_pickle(os.path.join(new_data_dir, 'df_train.pkl'))\n",
166 |     "    df_valid.to_pickle(os.path.join(new_data_dir, 'df_valid.pkl'))"
167 |    ]
168 |   },
169 |   {
170 |    "cell_type": "code",
171 |    "execution_count": 12,
172 |    "metadata": {},
173 |    "outputs": [
174 |     {
175 |      "name": "stdout",
176 |      "output_type": "stream",
177 |      "text": [
178 |       "# of obs in train set: 29337995 \n",
179 |       "# of obs in valid set: 7334499\n"
180 |      ]
181 |     }
182 |    ],
183 |    "source": [
184 |     "print('# of obs in train set:', df_train.shape[0], '\\n# of obs in valid set:', df_valid.shape[0])"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "code",
189 |    "execution_count": 13,
190 |    "metadata": {},
191 |    "outputs": [],
192 |    "source": [
193 |     "del df_train, df_valid, df_test\n",
194 |     "_ = gc.collect()"
195 |    ]
196 |   },
197 |   {
198 |    "cell_type": "code",
199 |    "execution_count": 14,
200 |    "metadata": {},
201 |    "outputs": [
202 |     {
203 |      "name": "stdout",
204 |      "output_type": "stream",
205 |      "text": [
206 |       "Elapsed time: 53 sec\n"
207 |      ]
208 |     }
209 |    ],
210 |    "source": [
211 |     "with get_elapsed_time():\n",
212 |     "    df_quiz = pd.read_csv(os.path.join(old_data_dir, 'test.txt'), sep='\\t', names=column_names[1:])\n",
213 |     "    df_quiz.to_pickle(os.path.join(new_data_dir, 'df_quiz.pkl'))"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "code",
218 |    "execution_count": 15,
219 |    "metadata": {},
220 |    "outputs": [
221 |     {
222 |      "name": "stdout",
223 |      "output_type": "stream",
224 |      "text": [
225 |       "# of obs in quiz set: 6042135\n"
226 |      ]
227 |     }
228 |    ],
229 |    "source": [
230 |     "print('# of obs in quiz set:', df_quiz.shape[0])"
231 |    ]
232 |   },
233 |   {
234 |    "cell_type": "code",
235 |    "execution_count": 16,
236 |    "metadata": {},
237 |    "outputs": [],
238 |    "source": [
239 |     "del df_quiz\n",
240 |     "_ = gc.collect()"
241 |    ]
242 |   }
243 |  ],
244 |  "metadata": {
245 |   "kernelspec": {
246 |    "display_name": "Python 3",
247 |    "language": "python",
248 |    "name": "python3"
249 |   },
250 |   "language_info": {
251 |    "codemirror_mode": {
252 |     "name": "ipython",
253 |     "version": 3
254 |    },
255 |    "file_extension": ".py",
256 |    "mimetype": "text/x-python",
257 |    "name": "python",
258 |    "nbconvert_exporter": "python",
259 |    "pygments_lexer": "ipython3",
260 |    "version": "3.7.6"
261 |   }
262 |  },
263 |  "nbformat": 4,
264 |  "nbformat_minor": 2
265 | }
266 | 


--------------------------------------------------------------------------------
/03_creating_xlearn_dataset.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "%load_ext autoreload\n",
 10 |     "%autoreload 2"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "metadata": {},
 17 |    "outputs": [],
 18 |    "source": [
 19 |     "import gc\n",
 20 |     "import os\n",
 21 |     "import pickle\n",
 22 |     "import pandas as pd\n",
 23 |     "from utils.data import *\n",
 24 |     "from utils.misc import *"
 25 |    ]
 26 |   },
 27 |   {
 28 |    "cell_type": "code",
 29 |    "execution_count": 3,
 30 |    "metadata": {},
 31 |    "outputs": [],
 32 |    "source": [
 33 |     "DATA_DIR = os.path.abspath('../../Data/display_advertising_challenge/processed')\n",
 34 |     "USE_QUIZ_SET = False\n",
 35 |     "USE_TEST_SET = False\n",
 36 |     "USE_FIELD = False\n",
 37 |     "USE_HASH = False\n",
 38 |     "TRAIN_SAMPLING_RATE = 1.0\n",
 39 |     "TEST_SAMPLING_RATE = 1.0"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": 4,
 45 |    "metadata": {},
 46 |    "outputs": [],
 47 |    "source": [
 48 |     "if USE_QUIZ_SET:\n",
 49 |     "    train_dataset_type = 'train+valid+test'\n",
 50 |     "    test_dataset_type = 'quiz'\n",
 51 |     "    \n",
 52 |     "elif USE_TEST_SET:\n",
 53 |     "    train_dataset_type = 'train+valid'\n",
 54 |     "    test_dataset_type = 'test'\n",
 55 |     "    \n",
 56 |     "else: \n",
 57 |     "    train_dataset_type = 'train'\n",
 58 |     "    test_dataset_type = 'valid'"
 59 |    ]
 60 |   },
 61 |   {
 62 |    "cell_type": "code",
 63 |    "execution_count": 5,
 64 |    "metadata": {},
 65 |    "outputs": [],
 66 |    "source": [
 67 |     "df_y_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', train_dataset_type]) + '.pkl'))\n",
 68 |     "df_X_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', train_dataset_type]) + '.pkl'))"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 6,
 74 |    "metadata": {},
 75 |    "outputs": [],
 76 |    "source": [
 77 |     "df_y_train.index = list(range(df_y_train.shape[0]))\n",
 78 |     "df_X_train.index = list(range(df_X_train.shape[0]))\n",
 79 |     "\n",
 80 |     "if TRAIN_SAMPLING_RATE < 1.0:\n",
 81 |     "    df_y_train = df_y_train.sample(frac=TRAIN_SAMPLING_RATE, random_state=42)\n",
 82 |     "    df_X_train = df_X_train.loc[df_y_train.index, :]"
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": 7,
 88 |    "metadata": {},
 89 |    "outputs": [
 90 |     {
 91 |      "name": "stdout",
 92 |      "output_type": "stream",
 93 |      "text": [
 94 |       "# of obs in sampled train set: 45840617\n"
 95 |      ]
 96 |     }
 97 |    ],
 98 |    "source": [
 99 |     "print('# of obs in sampled train set:', df_X_train.shape[0])"
100 |    ]
101 |   },
102 |   {
103 |    "cell_type": "code",
104 |    "execution_count": 8,
105 |    "metadata": {},
106 |    "outputs": [],
107 |    "source": [
108 |     "full_pipeline = load_pickle(os.path.join(DATA_DIR, '_'.join(['pipeline', train_dataset_type]) + '.pkl'))\n",
109 |     "target_name, num_feature_names, cat_feature_names, n_categories = load_pickle(\n",
110 |     "    os.path.join(DATA_DIR, '_'.join([train_dataset_type, 'metadata.pkl'])))"
111 |    ]
112 |   },
113 |   {
114 |    "cell_type": "code",
115 |    "execution_count": 9,
116 |    "metadata": {},
117 |    "outputs": [
118 |     {
119 |      "name": "stdout",
120 |      "output_type": "stream",
121 |      "text": [
122 |       "Elapsed time: 24827 sec\n"
123 |      ]
124 |     }
125 |    ],
126 |    "source": [
127 |     "with get_elapsed_time():\n",
128 |     "    model_type = 'ffm' if USE_FIELD else 'fm'\n",
129 |     "    train_dataset_path = os.path.join(DATA_DIR, '_'.join([model_type, 'dataset', train_dataset_type]) + '.libsvm')\n",
130 |     "    dump_libsvm_file(df_X_train, df_y_train, train_dataset_path, num_feature_names, cat_feature_names, \n",
131 |     "                     n_categories, use_field=USE_FIELD, decimals=6, use_hash=USE_HASH)"
132 |    ]
133 |   },
134 |   {
135 |    "cell_type": "code",
136 |    "execution_count": 10,
137 |    "metadata": {},
138 |    "outputs": [],
139 |    "source": [
140 |     "del df_y_train, df_X_train\n",
141 |     "_ = gc.collect()"
142 |    ]
143 |   },
144 |   {
145 |    "cell_type": "code",
146 |    "execution_count": 11,
147 |    "metadata": {},
148 |    "outputs": [],
149 |    "source": [
150 |     "df_y_test = pd.read_pickle(\n",
151 |     "    os.path.join(DATA_DIR, '_'.join(['df', 'y', test_dataset_type]) + '.pkl')) if not USE_QUIZ_SET else None\n",
152 |     "df_X_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', test_dataset_type]) + '.pkl'))"
153 |    ]
154 |   },
155 |   {
156 |    "cell_type": "code",
157 |    "execution_count": 12,
158 |    "metadata": {},
159 |    "outputs": [],
160 |    "source": [
161 |     "if not USE_QUIZ_SET:\n",
162 |     "    df_y_test.index = list(range(df_y_test.shape[0]))\n",
163 |     "df_X_test.index = list(range(df_X_test.shape[0]))\n",
164 |     "\n",
165 |     "if not USE_QUIZ_SET and TEST_SAMPLING_RATE < 1.0:\n",
166 |     "    df_y_test = df_y_test.sample(frac=TEST_SAMPLING_RATE, random_state=42)\n",
167 |     "    df_X_test = df_X_test.loc[df_y_test.index, :]"
168 |    ]
169 |   },
170 |   {
171 |    "cell_type": "code",
172 |    "execution_count": 13,
173 |    "metadata": {},
174 |    "outputs": [
175 |     {
176 |      "name": "stdout",
177 |      "output_type": "stream",
178 |      "text": [
179 |       "# of obs in sampled test set: 6042135\n"
180 |      ]
181 |     }
182 |    ],
183 |    "source": [
184 |     "print('# of obs in sampled test set:', df_X_test.shape[0])"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "code",
189 |    "execution_count": 14,
190 |    "metadata": {},
191 |    "outputs": [],
192 |    "source": [
193 |     "with get_elapsed_time():\n",
194 |     "    test_dataset_path = os.path.join(DATA_DIR, '_'.join([model_type, 'dataset', test_dataset_type]) + '.libsvm')\n",
195 |     "    dump_libsvm_file(df_X_test, df_y_test, test_dataset_path, num_feature_names, cat_feature_names, \n",
196 |     "                     n_categories, use_field=USE_FIELD, decimals=8, use_hash=USE_HASH)"
197 |    ]
198 |   },
199 |   {
200 |    "cell_type": "code",
201 |    "execution_count": 15,
202 |    "metadata": {},
203 |    "outputs": [],
204 |    "source": [
205 |     "if not USE_QUIZ_SET:\n",
206 |     "    del df_y_test, df_X_test\n",
207 |     "    \n",
208 |     "else:\n",
209 |     "    del df_X_test\n",
210 |     "_ = gc.collect()"
211 |    ]
212 |   }
213 |  ],
214 |  "metadata": {
215 |   "kernelspec": {
216 |    "display_name": "Python 3",
217 |    "language": "python",
218 |    "name": "python3"
219 |   },
220 |   "language_info": {
221 |    "codemirror_mode": {
222 |     "name": "ipython",
223 |     "version": 3
224 |    },
225 |    "file_extension": ".py",
226 |    "mimetype": "text/x-python",
227 |    "name": "python",
228 |    "nbconvert_exporter": "python",
229 |    "pygments_lexer": "ipython3",
230 |    "version": "3.7.5"
231 |   }
232 |  },
233 |  "nbformat": 4,
234 |  "nbformat_minor": 2
235 | }
236 | 


--------------------------------------------------------------------------------
/05_creating_deepctr_dataset.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "%load_ext autoreload\n",
 10 |     "%autoreload 2"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "metadata": {},
 17 |    "outputs": [],
 18 |    "source": [
 19 |     "import gc\n",
 20 |     "import os\n",
 21 |     "import pandas as pd\n",
 22 |     "from utils.data import *\n",
 23 |     "from utils.misc import *"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "code",
 28 |    "execution_count": 3,
 29 |    "metadata": {},
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "DATA_DIR = os.path.abspath('../../Data/display_advertising_challenge/processed')\n",
 33 |     "MODEL_DIR = os.path.abspath('models')\n",
 34 |     "USE_QUIZ_SET = False\n",
 35 |     "USE_TEST_SET = True\n",
 36 |     "TRAIN_SAMPLING_RATE = 1.0\n",
 37 |     "TEST_SAMPLING_RATE = 1.0"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "code",
 42 |    "execution_count": 4,
 43 |    "metadata": {},
 44 |    "outputs": [],
 45 |    "source": [
 46 |     "if USE_QUIZ_SET:\n",
 47 |     "    train_dataset_type = 'train+valid+test'\n",
 48 |     "    test_dataset_type = 'quiz'\n",
 49 |     "    \n",
 50 |     "elif USE_TEST_SET:\n",
 51 |     "    train_dataset_type = 'train+valid'\n",
 52 |     "    test_dataset_type = 'test'\n",
 53 |     "    \n",
 54 |     "else: \n",
 55 |     "    train_dataset_type = 'train'\n",
 56 |     "    test_dataset_type = 'valid'"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "code",
 61 |    "execution_count": 5,
 62 |    "metadata": {},
 63 |    "outputs": [],
 64 |    "source": [
 65 |     "df_y_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', train_dataset_type]) + '.pkl'))\n",
 66 |     "df_X_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', train_dataset_type]) + '.pkl'))"
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "code",
 71 |    "execution_count": 6,
 72 |    "metadata": {},
 73 |    "outputs": [],
 74 |    "source": [
 75 |     "df_y_train.index = list(range(df_y_train.shape[0]))\n",
 76 |     "df_X_train.index = list(range(df_X_train.shape[0]))\n",
 77 |     "\n",
 78 |     "if TRAIN_SAMPLING_RATE < 1.0:\n",
 79 |     "    df_y_train = df_y_train.sample(frac=TRAIN_SAMPLING_RATE, random_state=42)\n",
 80 |     "    df_X_train = df_X_train.loc[df_y_train.index, :]"
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "code",
 85 |    "execution_count": 7,
 86 |    "metadata": {},
 87 |    "outputs": [
 88 |     {
 89 |      "name": "stdout",
 90 |      "output_type": "stream",
 91 |      "text": [
 92 |       "# of obs in sampled train set: 36672494\n"
 93 |      ]
 94 |     }
 95 |    ],
 96 |    "source": [
 97 |     "print('# of obs in sampled train set:', df_X_train.shape[0])"
 98 |    ]
 99 |   },
100 |   {
101 |    "cell_type": "code",
102 |    "execution_count": 8,
103 |    "metadata": {},
104 |    "outputs": [],
105 |    "source": [
106 |     "full_pipeline = load_pickle(os.path.join(DATA_DIR, '_'.join(['pipeline', train_dataset_type]) + '.pkl'))\n",
107 |     "target_name, num_feature_names, cat_feature_names, n_categories = load_pickle(\n",
108 |     "    os.path.join(DATA_DIR, '_'.join([train_dataset_type, 'metadata.pkl'])))"
109 |    ]
110 |   },
111 |   {
112 |    "cell_type": "code",
113 |    "execution_count": 9,
114 |    "metadata": {},
115 |    "outputs": [
116 |     {
117 |      "name": "stdout",
118 |      "output_type": "stream",
119 |      "text": [
120 |       "Elapsed time: 38383 sec\n"
121 |      ]
122 |     }
123 |    ],
124 |    "source": [
125 |     "with get_elapsed_time():\n",
126 |     "    train_dataset_path = os.path.join(DATA_DIR, '_'.join(['dataset', train_dataset_type]) + '.tfrecord')\n",
127 |     "    dump_tfrecord_file(df_X_train, df_y_train, train_dataset_path, num_feature_names, cat_feature_names, \n",
128 |     "                       target_name=target_name, decimals=6, compression_type='GZIP')"
129 |    ]
130 |   },
131 |   {
132 |    "cell_type": "code",
133 |    "execution_count": 10,
134 |    "metadata": {},
135 |    "outputs": [],
136 |    "source": [
137 |     "del df_y_train, df_X_train\n",
138 |     "_ = gc.collect()"
139 |    ]
140 |   },
141 |   {
142 |    "cell_type": "code",
143 |    "execution_count": 11,
144 |    "metadata": {},
145 |    "outputs": [],
146 |    "source": [
147 |     "df_y_test = pd.read_pickle(\n",
148 |     "    os.path.join(DATA_DIR, '_'.join(['df', 'y', test_dataset_type]) + '.pkl')) if not USE_QUIZ_SET else None\n",
149 |     "df_X_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', test_dataset_type]) + '.pkl'))"
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": 12,
155 |    "metadata": {},
156 |    "outputs": [],
157 |    "source": [
158 |     "df_y_test.index = list(range(df_y_test.shape[0]))\n",
159 |     "df_X_test.index = list(range(df_X_test.shape[0]))\n",
160 |     "\n",
161 |     "if not USE_QUIZ_SET and TEST_SAMPLING_RATE < 1.0:\n",
162 |     "    df_y_test = df_y_test.sample(frac=TEST_SAMPLING_RATE, random_state=42)\n",
163 |     "    df_X_test = df_X_test.loc[df_y_test.index, :]"
164 |    ]
165 |   },
166 |   {
167 |    "cell_type": "code",
168 |    "execution_count": 13,
169 |    "metadata": {},
170 |    "outputs": [
171 |     {
172 |      "name": "stdout",
173 |      "output_type": "stream",
174 |      "text": [
175 |       "# of obs in sampled test set: 9168123\n"
176 |      ]
177 |     }
178 |    ],
179 |    "source": [
180 |     "print('# of obs in sampled test set:', df_X_test.shape[0])"
181 |    ]
182 |   },
183 |   {
184 |    "cell_type": "code",
185 |    "execution_count": 14,
186 |    "metadata": {},
187 |    "outputs": [
188 |     {
189 |      "name": "stdout",
190 |      "output_type": "stream",
191 |      "text": [
192 |       "Elapsed time: 9490 sec\n"
193 |      ]
194 |     }
195 |    ],
196 |    "source": [
197 |     "with get_elapsed_time():\n",
198 |     "    test_dataset_path = os.path.join(DATA_DIR, '_'.join(['dataset', test_dataset_type]) + '.tfrecord')\n",
199 |     "    dump_tfrecord_file(df_X_test, df_y_test, test_dataset_path, num_feature_names, cat_feature_names, \n",
200 |     "                       target_name=target_name, decimals=8, compression_type='GZIP')"
201 |    ]
202 |   },
203 |   {
204 |    "cell_type": "code",
205 |    "execution_count": 15,
206 |    "metadata": {},
207 |    "outputs": [],
208 |    "source": [
209 |     "if not USE_QUIZ_SET:\n",
210 |     "    del df_y_test, df_X_test\n",
211 |     "    \n",
212 |     "else:\n",
213 |     "    del df_X_test\n",
214 |     "_ = gc.collect()"
215 |    ]
216 |   }
217 |  ],
218 |  "metadata": {
219 |   "kernelspec": {
220 |    "display_name": "Python 3",
221 |    "language": "python",
222 |    "name": "python3"
223 |   },
224 |   "language_info": {
225 |    "codemirror_mode": {
226 |     "name": "ipython",
227 |     "version": 3
228 |    },
229 |    "file_extension": ".py",
230 |    "mimetype": "text/x-python",
231 |    "name": "python",
232 |    "nbconvert_exporter": "python",
233 |    "pygments_lexer": "ipython3",
234 |    "version": "3.7.5"
235 |   }
236 |  },
237 |  "nbformat": 4,
238 |  "nbformat_minor": 2
239 | }
240 | 


--------------------------------------------------------------------------------
/02_data_preprocessing.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "%load_ext autoreload\n",
 10 |     "%autoreload 2"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "metadata": {},
 17 |    "outputs": [],
 18 |    "source": [
 19 |     "import bisect\n",
 20 |     "import gc\n",
 21 |     "import os\n",
 22 |     "import pickle\n",
 23 |     "import numpy as np\n",
 24 |     "import pandas as pd\n",
 25 |     "from sklearn.compose import make_column_transformer\n",
 26 |     "from sklearn.impute import SimpleImputer\n",
 27 |     "from sklearn.pipeline import make_pipeline\n",
 28 |     "from sklearn.preprocessing import OrdinalEncoder, StandardScaler\n",
 29 |     "from utils.misc import *"
 30 |    ]
 31 |   },
 32 |   {
 33 |    "cell_type": "code",
 34 |    "execution_count": 3,
 35 |    "metadata": {},
 36 |    "outputs": [],
 37 |    "source": [
 38 |     "DATA_DIR = os.path.abspath('../../Data/display_advertising_challenge/processed')\n",
 39 |     "USE_QUIZ_SET = False\n",
 40 |     "USE_TEST_SET = False"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": 4,
 46 |    "metadata": {},
 47 |    "outputs": [],
 48 |    "source": [
 49 |     "if USE_QUIZ_SET:\n",
 50 |     "    train_dataset_type = 'train+valid+test'\n",
 51 |     "    test_dataset_type = 'quiz'\n",
 52 |     "    \n",
 53 |     "elif USE_TEST_SET:\n",
 54 |     "    train_dataset_type = 'train+valid'\n",
 55 |     "    test_dataset_type = 'test'\n",
 56 |     "    \n",
 57 |     "else: \n",
 58 |     "    train_dataset_type = 'train'\n",
 59 |     "    test_dataset_type = 'valid'"
 60 |    ]
 61 |   },
 62 |   {
 63 |    "cell_type": "code",
 64 |    "execution_count": 5,
 65 |    "metadata": {},
 66 |    "outputs": [],
 67 |    "source": [
 68 |     "df_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', train_dataset_type]) + '.pkl'))"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 6,
 74 |    "metadata": {},
 75 |    "outputs": [],
 76 |    "source": [
 77 |     "target_name = 'label'\n",
 78 |     "num_feature_names = df_train.columns[df_train.columns.str.startswith('I')]\n",
 79 |     "cat_feature_names = df_train.columns[df_train.columns.str.startswith('C')]\n",
 80 |     "all_feature_names = pd.Index(num_feature_names.to_list() + cat_feature_names.to_list())"
 81 |    ]
 82 |   },
 83 |   {
 84 |    "cell_type": "code",
 85 |    "execution_count": 7,
 86 |    "metadata": {},
 87 |    "outputs": [
 88 |     {
 89 |      "name": "stdout",
 90 |      "output_type": "stream",
 91 |      "text": [
 92 |       "# of num features: 13 \n",
 93 |       "# of cat features: 26\n"
 94 |      ]
 95 |     }
 96 |    ],
 97 |    "source": [
 98 |     "print('# of num features:', len(num_feature_names), '\\n# of cat features:', len(cat_feature_names))"
 99 |    ]
100 |   },
101 |   {
102 |    "cell_type": "code",
103 |    "execution_count": 8,
104 |    "metadata": {},
105 |    "outputs": [],
106 |    "source": [
107 |     "num_pipeline = make_pipeline(SimpleImputer(strategy='constant', fill_value=0.0, copy=False), \n",
108 |     "                             StandardScaler(copy=False))\n",
109 |     "cat_pipeline = make_pipeline(SimpleImputer(strategy='constant', fill_value='<unknown>', copy=False), \n",
110 |     "                             OrdinalEncoder(dtype=np.int))\n",
111 |     "full_pipeline = make_column_transformer((num_pipeline, num_feature_names), (cat_pipeline, cat_feature_names))"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "code",
116 |    "execution_count": 9,
117 |    "metadata": {},
118 |    "outputs": [],
119 |    "source": [
120 |     "df_y_train = df_train[target_name]\n",
121 |     "df_y_train.to_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', train_dataset_type]) + '.pkl'))"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "code",
126 |    "execution_count": 10,
127 |    "metadata": {},
128 |    "outputs": [],
129 |    "source": [
130 |     "full_pipeline = full_pipeline.fit(df_train[all_feature_names])\n",
131 |     "\n",
132 |     "for i in range(len(full_pipeline.transformers_[1][2])):\n",
133 |     "    categories = set(full_pipeline.transformers_[1][1].steps[1][1].categories_[i])\n",
134 |     "    if '<unknown>' not in categories:\n",
135 |     "        categories = list(categories)\n",
136 |     "        bisect.insort_left(categories, '<unknown>')\n",
137 |     "        full_pipeline.transformers_[1][1].steps[1][1].categories_[i] = np.array(categories)\n",
138 |     "        \n",
139 |     "n_categories = {feature: len(categories) for feature, categories in zip(\n",
140 |     "    full_pipeline.transformers_[1][2], full_pipeline.transformers_[1][1].steps[1][1].categories_)}"
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "code",
145 |    "execution_count": 11,
146 |    "metadata": {},
147 |    "outputs": [
148 |     {
149 |      "name": "stdout",
150 |      "output_type": "stream",
151 |      "text": [
152 |       "Elapsed time: 3881 sec\n"
153 |      ]
154 |     }
155 |    ],
156 |    "source": [
157 |     "with get_elapsed_time():\n",
158 |     "    df_X_train = full_pipeline.transform(df_train[all_feature_names])\n",
159 |     "    df_X_train = pd.DataFrame(df_X_train, columns=all_feature_names)\n",
160 |     "    df_X_train = df_X_train.astype({feature_name: 'int' for feature_name in cat_feature_names}, copy=False)\n",
161 |     "    df_X_train.to_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', train_dataset_type]) + '.pkl'))"
162 |    ]
163 |   },
164 |   {
165 |    "cell_type": "code",
166 |    "execution_count": 12,
167 |    "metadata": {},
168 |    "outputs": [],
169 |    "source": [
170 |     "dump_pickle(os.path.join(DATA_DIR, '_'.join([train_dataset_type, 'pipeline.pkl'])), full_pipeline)\n",
171 |     "dump_pickle(os.path.join(DATA_DIR, '_'.join([train_dataset_type, 'metadata.pkl'])), \n",
172 |     "            (target_name, num_feature_names, cat_feature_names, n_categories))"
173 |    ]
174 |   },
175 |   {
176 |    "cell_type": "code",
177 |    "execution_count": 13,
178 |    "metadata": {},
179 |    "outputs": [],
180 |    "source": [
181 |     "del df_train, df_y_train, df_X_train\n",
182 |     "_ = gc.collect()"
183 |    ]
184 |   },
185 |   {
186 |    "cell_type": "code",
187 |    "execution_count": 14,
188 |    "metadata": {},
189 |    "outputs": [],
190 |    "source": [
191 |     "df_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', test_dataset_type]) + '.pkl'))"
192 |    ]
193 |   },
194 |   {
195 |    "cell_type": "code",
196 |    "execution_count": 15,
197 |    "metadata": {},
198 |    "outputs": [],
199 |    "source": [
200 |     "for i, feature in enumerate(full_pipeline.transformers_[1][2]):\n",
201 |     "    categories = set(full_pipeline.transformers_[1][1].steps[1][1].categories_[i])\n",
202 |     "    df_test[feature] = df_test[feature].map(lambda x: np.nan if x not in categories else x)"
203 |    ]
204 |   },
205 |   {
206 |    "cell_type": "code",
207 |    "execution_count": 16,
208 |    "metadata": {},
209 |    "outputs": [],
210 |    "source": [
211 |     "if not USE_QUIZ_SET:\n",
212 |     "    df_y_test = df_test[target_name]\n",
213 |     "    df_y_test.to_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', test_dataset_type]) + '.pkl'))"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "code",
218 |    "execution_count": 17,
219 |    "metadata": {},
220 |    "outputs": [
221 |     {
222 |      "name": "stdout",
223 |      "output_type": "stream",
224 |      "text": [
225 |       "Elapsed time: 114 sec\n"
226 |      ]
227 |     }
228 |    ],
229 |    "source": [
230 |     "with get_elapsed_time():\n",
231 |     "    df_X_test = full_pipeline.transform(df_test)\n",
232 |     "    df_X_test = pd.DataFrame(df_X_test, columns=all_feature_names)\n",
233 |     "    df_X_test = df_X_test.astype({feature_name: 'int' for feature_name in cat_feature_names}, copy=False)\n",
234 |     "    df_X_test.to_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', test_dataset_type]) + '.pkl'))"
235 |    ]
236 |   },
237 |   {
238 |    "cell_type": "code",
239 |    "execution_count": 18,
240 |    "metadata": {},
241 |    "outputs": [],
242 |    "source": [
243 |     "if not USE_QUIZ_SET:\n",
244 |     "    del df_y_test, df_X_test\n",
245 |     "    \n",
246 |     "else:\n",
247 |     "    del df_X_test\n",
248 |     "_ = gc.collect()"
249 |    ]
250 |   }
251 |  ],
252 |  "metadata": {
253 |   "kernelspec": {
254 |    "display_name": "Python 3",
255 |    "language": "python",
256 |    "name": "python3"
257 |   },
258 |   "language_info": {
259 |    "codemirror_mode": {
260 |     "name": "ipython",
261 |     "version": 3
262 |    },
263 |    "file_extension": ".py",
264 |    "mimetype": "text/x-python",
265 |    "name": "python",
266 |    "nbconvert_exporter": "python",
267 |    "pygments_lexer": "ipython3",
268 |    "version": "3.7.5"
269 |   }
270 |  },
271 |  "nbformat": 4,
272 |  "nbformat_minor": 2
273 | }
274 | 


--------------------------------------------------------------------------------
/06_training_deepctr_model.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "%load_ext autoreload\n",
 10 |     "%autoreload 2"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "metadata": {},
 17 |    "outputs": [],
 18 |    "source": [
 19 |     "import os\n",
 20 |     "import numpy as np\n",
 21 |     "import pandas as pd\n",
 22 |     "import tensorflow as tf\n",
 23 |     "from sklearn.metrics import (accuracy_score, f1_score, precision_score, recall_score)\n",
 24 |     "from utils.data import *\n",
 25 |     "from utils.deep_learning import *\n",
 26 |     "from utils.measuring_performance import *\n",
 27 |     "from utils.misc import *\n",
 28 |     "from deepctr.inputs import DenseFeat, SparseFeat, get_feature_names\n",
 29 |     "from deepctr.layers import custom_objects\n",
 30 |     "from deepctr.models import DeepFM"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": 3,
 36 |    "metadata": {},
 37 |    "outputs": [],
 38 |    "source": [
 39 |     "def show_metrics_per_epoch(history, smoothing=False):\n",
 40 |     "    metrics_per_epoch = pd.DataFrame(history)\n",
 41 |     "    \n",
 42 |     "    if smoothing:\n",
 43 |     "        losses = metrics_per_epoch['loss'].rolling(window=10).mean()\n",
 44 |     "        val_losses = metrics_per_epoch['val_loss'].rolling(window=10).mean()\n",
 45 |     "        aucs = metrics_per_epoch['auc'].rolling(window=10).mean()\n",
 46 |     "        val_aucs = metrics_per_epoch['val_auc'].rolling(window=10).mean()\n",
 47 |     "        \n",
 48 |     "    else:\n",
 49 |     "        losses = metrics_per_epoch['loss']\n",
 50 |     "        val_losses = metrics_per_epoch['val_loss']\n",
 51 |     "        aucs = metrics_per_epoch['auc']\n",
 52 |     "        val_aucs = metrics_per_epoch['val_auc']\n",
 53 |     "    \n",
 54 |     "    fig = plt.figure(figsize=(10, 4))\n",
 55 |     "\n",
 56 |     "    ax1 = plt.subplot(1, 2, 1)\n",
 57 |     "    _ = ax1.plot(losses, linewidth=1.2, label='Training Loss')\n",
 58 |     "    _ = ax1.plot(val_losses, linestyle='--', linewidth=1.2, label='Validation Loss')\n",
 59 |     "    _ = ax1.set_title('Loss per Epoch')\n",
 60 |     "    _ = ax1.legend(loc='best')\n",
 61 |     "        \n",
 62 |     "    ax2 = plt.subplot(1, 2, 2)\n",
 63 |     "    _ = ax2.plot(aucs, linewidth=1.2, label='Training AUC')\n",
 64 |     "    _ = ax2.plot(val_aucs, linestyle='--', linewidth=1.2, label='Validation AUC')\n",
 65 |     "    _ = ax2.set_title('AUC per Epoch')\n",
 66 |     "    _ = ax2.legend(loc='best')\n",
 67 |     "    \n",
 68 |     "    return metrics_per_epoch"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "code",
 73 |    "execution_count": 4,
 74 |    "metadata": {},
 75 |    "outputs": [],
 76 |    "source": [
 77 |     "DATA_DIR = os.path.abspath('../../Data/display_advertising_challenge/processed')\n",
 78 |     "MODEL_DIR = os.path.abspath('models')\n",
 79 |     "USE_TFRECORD = True"
 80 |    ]
 81 |   },
 82 |   {
 83 |    "cell_type": "code",
 84 |    "execution_count": 5,
 85 |    "metadata": {},
 86 |    "outputs": [],
 87 |    "source": [
 88 |     "if not os.path.exists(MODEL_DIR):\n",
 89 |     "    os.makedirs(MODEL_DIR)"
 90 |    ]
 91 |   },
 92 |   {
 93 |    "cell_type": "code",
 94 |    "execution_count": 6,
 95 |    "metadata": {},
 96 |    "outputs": [],
 97 |    "source": [
 98 |     "train_dataset_type = 'train+valid'\n",
 99 |     "test_dataset_type = 'test'\n",
100 |     "model_type = 'deepfm'\n",
101 |     "model_path = os.path.join(MODEL_DIR, '_'.join([model_type, 'model', train_dataset_type]))\n",
102 |     "score_path = os.path.join(MODEL_DIR, '_'.join([model_type, 'score', test_dataset_type]) + '.pkl')"
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "code",
107 |    "execution_count": 7,
108 |    "metadata": {},
109 |    "outputs": [],
110 |    "source": [
111 |     "target_name, num_feature_names, cat_feature_names, n_categories = load_pickle(\n",
112 |     "    os.path.join(DATA_DIR, '_'.join([train_dataset_type, 'metadata.pkl'])))"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": 8,
118 |    "metadata": {},
119 |    "outputs": [],
120 |    "source": [
121 |     "if USE_TFRECORD:\n",
122 |     "    train_dataset_path = os.path.join(DATA_DIR, '_'.join(['dataset', train_dataset_type]) + '.tfrecord')\n",
123 |     "    test_dataset_path = os.path.join(DATA_DIR, '_'.join(['dataset', test_dataset_type]) + '.tfrecord')\n",
124 |     "    \n",
125 |     "    shuffle_buffer_size = 2 ** 20\n",
126 |     "    train_dataset = extract_dataset(train_dataset_path, compression_type='GZIP', \n",
127 |     "                                    shuffle_buffer_size=shuffle_buffer_size, is_training=True)\n",
128 |     "    test_dataset = extract_dataset(test_dataset_path, compression_type='GZIP', \n",
129 |     "                                    shuffle_buffer_size=shuffle_buffer_size, is_training=True)\n",
130 |     "    \n",
131 |     "    n = get_n_examples(train_dataset)\n",
132 |     "    m = get_n_examples(test_dataset)\n",
133 |     "    \n",
134 |     "else:\n",
135 |     "    df_y_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', train_dataset_type]) + '.pkl'))\n",
136 |     "    df_X_train = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', train_dataset_type]) + '.pkl'))\n",
137 |     "    df_y_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'y', test_dataset_type]) + '.pkl'))\n",
138 |     "    df_X_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', test_dataset_type]) + '.pkl'))\n",
139 |     "\n",
140 |     "    train_model_input = {column: df_X_train[column].values for column in df_X_train.columns}\n",
141 |     "    test_model_input = {column: df_X_test[column].values for column in df_X_test.columns}\n",
142 |     "    \n",
143 |     "    n = df_y_train.shape[0]\n",
144 |     "    m = df_y_test.shape[0]"
145 |    ]
146 |   },
147 |   {
148 |    "cell_type": "code",
149 |    "execution_count": 9,
150 |    "metadata": {},
151 |    "outputs": [],
152 |    "source": [
153 |     "embedding_dim = 4\n",
154 |     "num_features = [DenseFeat(feature, 1) for feature in num_feature_names]\n",
155 |     "cat_features = [SparseFeat(feature, vocabulary_size=n_categories[feature], \n",
156 |     "                           embedding_dim=embedding_dim, use_hash=False) for feature in cat_feature_names]\n",
157 |     "linear_features = num_features + cat_features\n",
158 |     "dnn_features = num_features + cat_features\n",
159 |     "all_feature_names = get_feature_names(num_features + cat_features)"
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "code",
164 |    "execution_count": 10,
165 |    "metadata": {},
166 |    "outputs": [],
167 |    "source": [
168 |     "model = DeepFM(linear_features, dnn_features, task='binary')\n",
169 |     "\n",
170 |     "if len(get_available_gpus()) > 1:\n",
171 |     "    model = tf.keras.utils.multi_gpu_model(model, gpus=n_gpus)\n",
172 |     "    \n",
173 |     "model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=[tf.keras.metrics.AUC()])"
174 |    ]
175 |   },
176 |   {
177 |    "cell_type": "code",
178 |    "execution_count": 11,
179 |    "metadata": {},
180 |    "outputs": [],
181 |    "source": [
182 |     "callbacks = [tf.keras.callbacks.EarlyStopping(monitor='val_auc', patience=3, mode='max'),\n",
183 |     "             tf.keras.callbacks.ModelCheckpoint(\n",
184 |     "                 filepath=model_path + '.h5', monitor='val_auc', save_best_only=True)]"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "code",
189 |    "execution_count": 12,
190 |    "metadata": {},
191 |    "outputs": [],
192 |    "source": [
193 |     "epochs = 300\n",
194 |     "batch_size = 2 ** 17"
195 |    ]
196 |   },
197 |   {
198 |    "cell_type": "code",
199 |    "execution_count": 13,
200 |    "metadata": {},
201 |    "outputs": [],
202 |    "source": [
203 |     "if USE_TFRECORD:\n",
204 |     "    steps_per_epoch = n // batch_size\n",
205 |     "    validation_steps = m // batch_size\n",
206 |     "    \n",
207 |     "    train_dataset = transform_dataset(train_dataset, num_feature_names, cat_feature_names, \n",
208 |     "                                      target_name=target_name)\n",
209 |     "    test_dataset = transform_dataset(test_dataset, num_feature_names, cat_feature_names, \n",
210 |     "                                     target_name=target_name)\n",
211 |     "    \n",
212 |     "    train_generator = load_dataset(train_dataset, batch_size=batch_size, is_training=True)\n",
213 |     "    valid_generator = load_dataset(test_dataset, batch_size=batch_size, is_training=True)\n",
214 |     "    \n",
215 |     "    history = model.fit_generator(train_generator, steps_per_epoch=steps_per_epoch, epochs=epochs, \n",
216 |     "                                  verbose=False, validation_data=valid_generator, \n",
217 |     "                                  validation_steps=validation_steps, callbacks=callbacks)\n",
218 |     "    \n",
219 |     "else:\n",
220 |     "    history = model.fit(train_model_input, df_y_train.values, batch_size=batch_size, epochs=epochs, \n",
221 |     "                        verbose=True, validation_data=(test_model_input, df_y_test.values), callbacks=callbacks)\n",
222 |     "    \n",
223 |     "history = history.history"
224 |    ]
225 |   },
226 |   {
227 |    "cell_type": "code",
228 |    "execution_count": 14,
229 |    "metadata": {},
230 |    "outputs": [],
231 |    "source": [
232 |     "model.save(model_path + '.h5')\n",
233 |     "dump_pickle(model_path + '_history.pkl', history)"
234 |    ]
235 |   },
236 |   {
237 |    "cell_type": "code",
238 |    "execution_count": 15,
239 |    "metadata": {},
240 |    "outputs": [
241 |     {
242 |      "name": "stderr",
243 |      "output_type": "stream",
244 |      "text": [
245 |       "/Users/a406127/anaconda3/envs/ctr_prediction/lib/python3.7/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
246 |       "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n",
247 |       "/Users/a406127/anaconda3/envs/ctr_prediction/lib/python3.7/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
248 |       "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
249 |      ]
250 |     }
251 |    ],
252 |    "source": [
253 |     "model = tf.keras.models.load_model(model_path + '.h5', custom_objects=custom_objects)\n",
254 |     "history = load_pickle(model_path + '_history.pkl')"
255 |    ]
256 |   },
257 |   {
258 |    "cell_type": "code",
259 |    "execution_count": 16,
260 |    "metadata": {},
261 |    "outputs": [
262 |     {
263 |      "data": {
264 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAEFCAYAAAA2dTkSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3hUVfrA8e+0ZNJ7IKGlwaEHaYKKuBYUEUVFZRULoiiuXde1/QR2UVZde0XXrrt2RBQ7roCAUqSEciCUkNBSSC+Tycz8/rhDDDFAEpJMyvt5Hh8zd25573Bz8845557X5PF4EEIIIYQQzcfs6wCEEEIIIdo7SbiEEEIIIZqZJFxCCCGEEM1MEi4hhBBCiGYmCZcQQgghRDOThEsIIYQQoplZfR2AaHlKqQQgTWsd7OtYjodS6k3gLCCn1luva62fbYZjpWmt/9WU+xVCNJ5SygZkAOu11ufUWO4BYrTWuTWWTQRu1lqf5n0dDvwdOA1wAx7gea31ay0U+0zgL8CeWm99rbW+txmOFa21vrkp9ysaRhIu0dY9JUmQEB3WhcB6YIhSqo/WenN9NlJK2YGfgPeAwVrrKqVUD+AHpRQtlXQBH0gS1HFIwiUOo5QKA14ABmF84/sKuN97Q5qFcYOrBPKAa7TW+460vNZ+3/Turw8QA3wL3Kq1diql+gDPAFGABXhWa/26Uuo07/JSIAgYrrV2NOBcdgHzgFFAOPCE1vol73vTgFsBF3AA45vvVqVUMPAccDJQBXwGPODd5UlKqWVAJyANuFxrXVrfeIQQTe4m4H0gHbgduKGe210GlGitHzu0QGudoZS6FPCrvbK3hagf0Bnj938tcJ3Wukgp1QV4HugO2ID3tdaPeHsSlgCbgQRgdO374tEopf4HbAKGAtHAO1rrGd73JgAzMO6XRcCdWutflVJW4DHgPIz71zKMzwigt1LqRyAO4543qSHxiOMnCZeo7VmMpGkAxo3nc+BupdR7GDe0WK21Qyl1F3CiUmp1XcsxEpXaUoFTASdGwnWDUupl4GPgSq31Gm/Ct1wptcm7TX8gSWudcYR471BKTa617Eqt9Qbvz4HAMKAL8JtSailGwncPMFJrnaOUugb4TCnVD6OLwY6RGFqA74DR3n11Af4EOIBfgYuAd474SQohmo1Sqi8wAuP3cDXwk1Lqfq11Xj02Hwr8XHuh1nrNUbYZ4d0uB3gXeAi4G+Me8JTWeoG35WyhUiod4x7RFeOL2ZIj7PMypdQptZb9TWv9jffnHhhf/oKAFUqplRjJ5cvASVrrHUqp04H5SikFXAMMwbjXOoD/YiSXAEnAid573mfAdcA/jnK+oolJwiVqGwucrLX2AA5vQnQ7xremdcAapdRXwFda6x+UUua6lh9h329qrUsAlFJvAxOARUAy8LpxvwAgADgB45th5lGSLTh2l+IL3nPJUkp9DYzB+Ib6gdY6B0Br/aZS6hmMb6FnYnxbdGG0fo32xnsN8JnWusz7Og2IPcpxhRDNazrwpdb6IHBQKbUTo4XrEYzW9NrMGL/TYIzZauhDYx9prQ8AKKVeA55WSs3AuEdEKqUOJS/BGD0Ev2K0Mi0/yj6P1aU4V2vtBAqUUh8BZ2O0pP2gtd4BoLVepJTKxki0zsRoCSv3bn+ZN96ZwHeH7nkY92y5f7UwSbhEbbVvQmbAprV2K6VGY3zDOxN4Sin1o9b6tiMtr2PfVbX268JoRSrQWg869IZSqhNQiPGNsuQ4z6euY9Z1ozVhdAdUUeNmrZTqBpR5XzprrO/xbiOEaGFKqSDgKqDCO3QAIBT4i1LqcSAXY4hCbo3NOmG03gOswBiwXnu/5wOjtNZ/reOwR7p/mTBamw59GYsGKjC6AR1a66raO2qA+t6/zNR9/+pUY325f/mYTAshavsG46ZlUkr5A9OA75RSqRjjljZrrecATwGpR1p+hH1fppTy9za7Xw0sADTGTXMyVCc4aRjf1prCVd79dsdo3frKe46XKaVivO9NwbgRpwPfA1crpcze8/+Y37sUhRCtwxUYyVS81jpBa52A0WUWDFyK8Xt+q7cFHqVUBMY9Z6F3+0+AMKXUPUopi3edJOBJjJb1ulyglArz7vN6YIHWuggjebvTu49wjK7KC5roPCd770UR3vNagNErMMYbL94uxW7ALxj3r8u991kz8BLw5yaKRRwnaeHquIKUUrVbj0ZiDCR/DtiAMYbra+BhrXWlUupDYJV3u3KMQe/r6lp+hGOWYQwijcBIZN7wtpxdADyjlLoH41va/2mtf/YOmj+WusZwrdBa3+j9OdE7zizAG68GtFLqKWCR96aUA5znjWUWxkD9dRjfXj/QWn/q/eYrhGgdpgNPerv+AdBaFyilnsUYAnEW8ASQppSqwmjNeRt4y7tupVLqTIyhEhu867iA2VrrN49wzAMYCVs0sBij6xLgcuB5pdShe+Z/tdbveQfNH0tdY7h2a60P3W8CMLomQ4AXDw3XUErdBHzqHSRfBozXWhcqpeZiDI1Y7T3n/2GMy32wHrGIZmbyeOrq6haiaSkfzGPl7WqYqLVe1VLHFEK0P8oH81h5n1J8Xmv9cUsdUzQv6VIUQgghhGhm0sIlhBBCCNHMpIVLCCGEEKKZScIlhBBCCNHMWvVTijk5xc3e3xkREUh+ftmxV5Q4JA6Jo0XiiIkJabL5gbxPob7I7zNvX6e1Tq/x/l0YT5m5gUe01vNqvHchcInW+nLv6xEYT7BWAd9qrWcd6/hyD5M4OnoMHS2Oo92/OnwLl9Vq8XUIgMRRm8RxOImj0SYAdq31SOBejKkCgOo5k27DmA5lDPB0jfeeAeZw+D3yZYzk7BSMslYnNHv09dBa/k0kjsO1hjhaQwwgcRzS4RMuIUS7dgrGXHJorVdgVEQ4pBTIwKhTF4TRynXIMoy5ngBQSoUC/lrr7d5SUd9gVFYQQoh6adVdikIIcZxCMcpEHeJSSllrlFvJBDZhTHI759BKWusPak28GwoU1XhdjDGz+VFFRAS2yLfqmJiQZj9GfUgch2sNcbSGGEDiAEm4hBDtWxHGLN2HmGskW2OBOCDR+/obpdTPWutf67GfEKDgWAdviXErMTEh5OQUN/txJI62F0driKGjxXG0hE66FIUQ7dnPwLlQPeh9Q4338jFKUTm01hUYCVR4XTvx1syrVEolK6VMwNkYZaqEEKJepIVLCNGezQPOUkotw6gtN0UpdSeQrrX+3FtPb4VSyg0sBb47yr5uBN7D6H78Vmv9SzPHLoRoRyThEkK0W1prN0aiVNOWGu/PAGYcYdv/YRT/PfR6BTCiyYMUQnQI0qUohBBCCNHM2lXC5XK7fB2CEEIIIdqB0gonaTvzKHdUHXvlemg3XYqrD6zjf1k/c9sJ07Ca281piTbsueeeQuvNHDyYR0VFBfHxXQgPj2D27EePue22bZqlSxczZcr1db6/YsUyDhzYzwUXXNTo+M4//2w+//ybRm8v2qbWfl0CbNqUxk03XcdLL71Gnz79AFi4cAEZGbuYPv2W6vVmzLiPCy64mMGDh7Jjx3ZeeulZXC4nRUUljBx5MtdeOw2TqckKF4h2rqTcydbMAvTuAvTufDKzSwi0W7lr0iASOoce9/7bTWaiIlOYl/4l87d/xcU9x/s6HCG45ZY7gLr/UBxLz56Knj3VEd8fMeKk445PdExt4bpcsOAzJk2azKeffsQDD/Q75vrFxcXMnHk/Dz/8OIMH92P//gL+7//uZf78T5gwYWKTxCTan5JyZ3VypTMLyMouISjAhuoWzskD4+jdPYIuMUGYmyhpbzcJV7AtiKn9r+CpNS+TEp5Iakx/X4ckWpmyCicOp/vYK9Zg9rOSX+yo8z1/m5lAu63BcaxZs4qXXnoOm83G+edfiL+/P59++hFVVVWYTCYeeeRf7NiRzvz5nzBr1hwmTbqQYcOGsnVrOpGRkcye/RjffLOQjIxdTJhwMTNnPkBsbCf27Mmib99+3H33fRQUFDBr1gM4nU66devBmjUr+eCDz44Z2759e5kz5++4XC5MJhO33XY3PXv24pFHZpGVlYnL5eTCCy/lnHPGMXfuC/z222pcripGjz6dyZOvafBnIRp3XdZU+xptyetywIBUdu/OIDIykrlzX6pO4o7nuiwrK2P16pW8886HXH31JAoKCggPr3O2jmpLl/7E4MHD6NatOwAWi4UHH5yFzdbwz0G0X4UlDlZtyUZnGklWVk4pwQE2VPdwTk2NR3UPJz666RKs2tpNwgWQGNaDCcljWbJnBQOj+0lTsqjmcrv560vLKHc03Ti/AH8Lz942Cou54UMhKysrefXVtwB4++3XefzxZ7Db7Tz22MP8+utyoqNjqtfdu3cPt932DlZrMNOnX8vmzZsO21dm5m6eeup5/P3tXHrpBeTl5fLee28xatRpXHTRJaxcuYKVK1fUK64XXniaSy6ZxKhRp7Ftm+af//wHzz33MmvXrmHu3DeJjg7mq69+AOC7777muefmEhUVzcKFCxr8GYi2f10+88xLdOrUmenTr2XDhg2H7aux1+UPP3zL6NGn4+/vz+mnn8UXX3x21GTeZDKRm5tDfHyXw5YHBgY2+PxF+1LuqEJnFrB5Vz6bMw6SlVNKSKAN1T2C007ogupmJFgtlSu0q4QL4E/dRnFq15MwmUx4PB5JugQAFrOZx6ef1OCWhKioIPLySut8z99mbtQfNYDu3XtU/xwREcns2TMIDAwkI2MX/fsPPGzdsLBw4uLiyMkpJja2E5WVh7e4denSlcDAIG+80VRWVrJr1y7Gjj0PgIED619jedeuXaSmDgaM7qPs7AMEBgZx66138dhjD+N0VvCnP40B4KGH/sHLLz9HXl6edHE2UmOvy5pqX6MteV126tQZgNjYTjgcTXNdLljwGRaLhTvvvAWHo4Ls7Gwuv/wq/P39cTorD1u3vLwcf39/OnWKY+vWLYe9t3fvHrKzDzBo0OBGfBKiLXJWudm+p5BNGUaCtXNvMf5+Fnp3D2f0oC6cNKgLdjM+ywvaXcJlMpmwmqx8v/sn8isKuKTXBb4OSbQSgXYbgfaGbRMVFoC7smmeUKnJbDZ+4UtKSnjttbl88skXANxxx1/weDyHrXusm0Nd7yclJZOWtoGePRUbN26oY6u6JSQksH79b5xyymi2bdNERkaRm5uL1puZM+dfhIb6ceqpp3LWWefw448/MHPmIwBMnnwJZ555Np07x9X7WMLQmOuypqa8Rn19XW7fno7b7eaVV96sXnb77TexbNkSevbsxZtv/puysjICAwMpKipkx47tJCQk0aNHAu+88zoXXjiRmJg+VFVV8dxzTzFs2ImScLVjbreHjAPFbM7IZ/Oug2zLKsQD9OwaxqCUaC4/sxc9OoVUX9e+LjHU7hKuQ3qGJ/Hk6hdJDk9kcOzAY28ghA8EBQUxYEAqN944BYvFSkhICLm5OcTFxR/XfidPvoZ//OMhFi36jujoGKzWP/6qFxYWMHXqldWvJ026gr/85XYefXQ2//3vu1RVVXHfff9HVFQUBw/mceON1+Lvb2PSpMn4+fkRGhrKtGnX4O/vz7BhI6pbO0Tb56vrcsGCeZx99rmHLRs//kI++eRDnnrqBS666FJuuuk6AgMDqaqq4vbb767uOnzggVk8+uhsrFYzBQVFnHzyKC68UAbMtzfZBeVs3JHHpl35bNmdT7nDRWJcCH0SIjh3ZAIpXUKxtUDB+MYw1f7W0prk5BQfV3D/y/yZBTu+5m/DbiM2MLrOdXyd8UocEkdzxLF8+VLCwyPo06cfK1f+wjvvvMGzz77c4nE08hjtZhzA8d7D6qMtXaPNdV02NI6W0BriaA0xHG8cjkoXm3fns3HHQTbszCM7v5y4qED6JUTSJyEC1S2CQHv92o58ff9qty1cAKO7nkR6wQ5+zFzCZepCX4cjRIuJi+vCnDl/x2Kx4Ha7uf32u30dkhByXYpj8ng87MkpZcPOPNJ2HGRbVgE2q4W+CRGcO6IH/RMjiQw9jj54H2rXCZfJZOLKvpdhNbXO5kUhmktCQiJz577h6zCEOIxcl6IuJeVONu06SNqOg6TtzKOwpJKEuBD6JUYxYVQiSfGhjX4QpDVp1wkXgL/FD4CPt35OQmg3hnau/xNbQgghhGhaHo+H3QdKWLc9lw3b89ixr4iQQD/6J0Zy6Z9S6JsYSWign6/DbHLHTLiUUmbgRSAVcADXaa3T61jnS2C+1vplpZQJyAK2eVdZrrW+Tyl1BXAX4AJe11q/1HSncnSxgTH8R39Ct5AudAqKbanDCiGEEB1epdPF5ox81qXnsm57HgUlDpK7hDGoZzSTxyi6dQputglHW4v6tHBNAOxa65FKqRHAE0DtuRZmAxE1XicDa7TWtWvs/AvoB5QAm5RS72ut8xsXesOM6jKC9IId/DvtXf469Gb8LO0vexZCCCFai/xiB+u257JldyFrt2ZjsZjonxjFxaOTGJAURUg7bMU6mvokXKcAXwNorVcopYbWfFMpNRFwH1rHawjQRSn1I1AO3KG11sB6IAyoAkxAiz0iaTKZuLz3xTy66lmW7V3Jad1ObqlDCyGEEO2e2+MhY3+x0YqVnkfGgWJiwwMYMTCO2wYOpGe3cKyWtj8Wq7Hqk3CFAoU1XruUUlatdZVSqj9wOTAReKjGOvuAOVrrj5RSpwDvAsOANGA1UAp8qrUuONqBIyICsTbpfBohzD7zbkLtIZhNv/+jx8SENOExGk/iOFxbj2Py5Mn85S9/YeTIkdXLZs+ejVKKSy655A/rZ2Vlceedd/Lhhx9yxx138Oijj+Ln9/s3wM2bf2PhwoX885//rPN4DoeDzz//nEsuuYRPP/2UsLAwzjjjjEbFXjOW2lrLv4tonJtvnsaUKdczZMiw6mVPP/0vkpNTGD9+wh/W37dvLzNm3M8rr7zJjBn38eCDfz+sRuGKFcv44YdvefrpJ+o8nsPh4Ntvv2L8+AksXLiA0NBQTjll9HGdww8/fMecObN4//151eWGXnttLlFRUVx//ZTq9aZNu4ZZsx4hLi6edet+4403XqWqqoqKigrOPXc8F130x99D0TBVLjdbduezaksO67bnUlzqpGfXME7s24lp5/elc2QgsbGhrWJ6Cl+rT8JVBNS8w5q11oemNb4K6AIsAhKASqXULmAxRisWWuulSql4pVQqMA5IxOhSfFcpdYnW+qMjHTg/v6xBJ1M/ZrKLiviv/pQzup/KwISUVnEhtIf5UiSOw51zzng++OBjUlKMQupOp5Pvv1/EVVdNq3OfBw+W4nS6yMkp5v77/05hoQNj2KQRR2FhORUVziPGs2/fXv7zn/c57bRzGDXqLIBGx14zlppaaB6bZt1/Rzd+/AS+/vrL6oTL6XTy889LuOGGvxxz21mz5jT4eAcP5rFgwWeMHz+Bc8+tPcqkcRYsmMfEiZOYP/9Tpk694Zjr79mTxdNPP84TTzxHZGQUDkcFt9xyI/HxXaQsVSO43G62ZBSwcssBVuscqlweUlOiuOz0FPonRhEcIEXD61KfhOtnYDzwoXcMV3U9Bq31PYd+VkrNBPZrrb9WSj0K5AGPeROtTKAAo3uxXGvtUkplc/i4rxZjNpmpcrv4d9q7PNb1Pl+EIHygoqqCCtfv9d5MmAjzD8XldlHsLDls3SBrIDaLjaKKYgocvzfw2sw2gmyBOFyVeDxu7NYjzwdz2mlnMHfuC1RUVGC321my5CeGDz+RgIAAfvttNW+88Sput5vy8nJmzJh9WKvBxInjee+9j9m3by9z5vyd0NBgLBYbISGhAHzyyQf89NOPlJeXEx4eziOP/Iu3336dXbt2Vu83KiqKCRMm8txzT7F+/VoAzjrrHC699M88/PBMbDYb+/fvIy8vl/vvn4lSvY/5GW7atImHHpqJxWLBz8+Pe+55kIiICB566F5KS0upqKhg2rSbGD58BI88MousrEwcDgeXXDKJc84ZV79/qA6mMddlcWUJLo9R8NpS7qLU6fDJdWm3BxAQYG/R63Lv3j0UFRVxxRVXM3XqZK6+emqdlRRq+uabhZxzzjgiI6MA8Pe38+STzxMQEHCsfx7h5XK72bK7gFVbslmtc6iscpGaHM3V5/RmQHIU/jaZfulY6pNwzQPOUkotwxh3NUUpdSeQrrX+/Ajb/BOjBWscRkvXNVrrDKXUXGCpUqoS2A68edxn0Agmk4lJ6kIeX/Ucr676D5cmXXRYF6Non37YvZiFu76vfm232Hli9N/Jq8hn1orHDlv3xoHXMCC6L48ueZFtB3dVLx8cO5Cp/SezfN9KSitLGZc05ojH8/f359RTT2Px4h8ZM2YsCxd+zrRpNwGwc+cOHnroH0RHx/D226/z44/fM2bM2D/s48UXn+G6627g3HPP4qmnniMjYxdut5vCwkKefvpFzGYzd955M5s3b+Sqq65l+/Z0pky5ntdemwvAzz8vYd++vbzyypu4XC6mT59a3bLRuXMc99zzAJ9/Po/PP/+Uv/71/mN+hg8++CB3330/PXsqliz5H88//yTXXnsDhYWFPPHEs+Tn55OZmUFZWSlr165h7tw3MZlM/PrrimPuu6NqzHX58vo32VW0u3q5r67LYcNG8O67b7bodfnFF/MZN+58QkJC6N9/ID/9tIgzzjjy+ZpMJnJzc+jZs9dhy4ODg4+4jTC43G60N8lapXOodLoYmBLNVWcrBiRF4e8nSVZDHDPh0lq7gRtrLd5Sx3oza/ycj9F9WHudl4GmrePQSHarP1P7T+bZda+QEpQs83N1AGd0P5WTu5xY/dqE8QhylD2Ch09+4LB1g6xGfba/jbqJA7mHt3ABjIwbhsfjPuYxx4+/kBdeeIYTThhCcXExvXoZ39ZjYmJ4+unHCQgIJCcnmwEDUuvcfvfu3fTpY3RJDhgwiIyMXZjNZmw2GzNnPkBAQADZ2dlUVdVdvDgjYyepqYOMou5WK/36DWDXrh0A9OypAIiN7cSGDeuOeS4A2dnZ1dulpg7m5ZefJykpmQsuuIiZMx+gqqqKiRMnERgYxK233sVjjz1MWVlpnX+0haEx1+WNA6+pbuGKigqmKN9oIWvv16XL5eLbb78iLi6en39eQnFxIZ98so8zzhiDv78/lZXOw9YvLy/D39+fzp3jyM4+cNh727ZtxeNxV5+7MLjdHnRmASu3ZLNaZ+OodDEgOYrJY3qRmhwtSdZxaPcTnx5NfHBnnjrnIcqL3FRUVbAhdzNDOw2qs8q9aPvsVnudXS0Ws4Vw/7A6twm1h+Dw/+Ny/3pOK5KcnEJ5eSkfffQ+48adX7380Ucf5sMPPyMwMIjZs2cccfvExETS0taTmBjHli0bAUhP38bixf/j1VffoqKigqlTJwNgMpn/8Me2R49EFi78nMsuu4KqqirS0tYzdux5wLJGXeexsbGkp28jJaUna9euoVu37mzfnk5ZWSmPP/4Mubm5TJ9+LUr1QevNzJnzLxwOBxdfPI6zzz73mF0/HVFjrssQv99bZyIDQnCVGOPqWvq6HDHipOrrcsuWLc1+XS5f/jO9e/dl9uxHq5dNmnQR6enbUKo37777FjfccC1gjNtyOp1ERERy1lnncN99d3P66WOIiIigrKyMxx9/hClTrqvX59URZGWXsCxtP8s37aesooqBSVFccVYvBiZHYfeT39um0OE/xVB7CI7iYjKL9/If/Qlrstdzee+LD7uhCXE8xo07nxdeeJZPPvmietnZZ4/lppuuJyDATkREFLm5OXVue/PNdzB79gw+/vg/BAWF4OfnT9eu3QgICGD6dOMPS1RUNLm5OfTrNwCns4oXX3wWf38jSzz55FH89ttqbrhhCk6nk9NPP7NeY7UAdu7cztSpV9aI5XZmz57NzJl/x+PxYLFYuPfe/yM6OoY33niFRYu+x+12M3XqDURFRXHwYB433ngtZrOZSZMmS7LVyjTFdfnf/75DeHg4fn7+9OjRo9mvywUL5v3hScrx4y/gk08+5G9/e4D169dx0UUX4e8fgMfj4cEHZwEQFxfPTTfdygMP/BWz2UxZWRnjx09g5MhTGvXZtReFpZX8snE/y9L2k5ldQu8eEUwcnczgXjEE+Mvva1MzeTwtNhVWg+XkFDd7cDWfusopy+PtzR+QU5bLFX0mMiC6b3Mfvs44fEnikDh8HUdMTEi7aWJu6XuYL0kcrS+OumKodLpYm57LsrT9pO04SKfIAE7q35mR/To3W1Ho1vBZtFQcR7t/SQpbQ0xgFHcMvpHvM36iyOH7i0MIIYQ4Xh6Ph21ZhSxL28/KLdlYzCZO7NOJB64aQkLnEBlG00Ik4arFbDIzJuFPAJQ5y3h5/Vucn3wOKeGJPo5MCNFQx6oFq5S6C2PyZjfwiNZ6nlIqAGOy5ligGLhaa53jy1qwQjTGvtxSvliyg2Vp+8kvdjAoJZrrxvVhQHJUh57x3Vck4ToKm9lGQmg3nvltLmd0O5VxSWOwmeUjE6INOWItWKVUOHAbkAIEAWsxpsGZDmzQWs9USk0CHvSu57NasELUl7PKzeqt2Sxeu5ctuwtIjg9l7IndGdank0xI6mOSPRyFzWLjop7nMSC6D29v/pAdhbu4Y/B0aX4Vou04Wi3YUiADI9kKwmjlOrTNoQmwvgL+z/uzz2rBCnEse3NLWbxuL8vS9gNw8oDO3DppMHZpyGo1JOGqh54Rydw//A72lOzDZDKRXZZLdECkTJYqROt3xFqw3teZwCbAAsypY5tijCQLGlgLFpqjHmzdWks5JInjcM0dh8PpYtn6vXyzIoONO/IYmBLN9IsHMnJAHLYWuO4aoqP8mxyNJFz1FGC1kxKeiNvj5tUNbxPiF8y1/a8g2Bbk69CEEEd2tFqwY4E4jPquAN8opX6utU0IUKCUGkgDa8FCc9WDPVxHegJM4jBk5ZSweK3RmmWxmDhlQByTz+xJp0hjYtwC73XXET6L1hbH0RI6aaJpILPJzM2DrqPS5eSxlc+SVbzX1yEJIY7sZ+BcgNq1YIF8jPquDq11BUa91/Ca22AkZUswWryqa8ECPqsFKzomh9PF0vX7ePidVTz02q/syyvl6rG9eeIvJ6Xqa4EAACAASURBVHPJn1Kqky3RekkLVyOE+Ydy2+Ab+GjrfF5a/wYzR/5NBtML0TodtRasUupMYIVSyg0sBb7z/v8tpdRSoBK4XGu9v7XUghUdy4H8Mr5flcWytP34Wc2cMjCO68/rS2yEJFhtjWQJjWQzW7m898UUOAqxma3sLdlP56BYGdclRCtyrFqwWusZQO0aNmXAJXXsq9XUghXt26F5s775dTdrt+Wiuodz7bm9SU2Jlukc2jBJuI5TuH8Ybo+bf6e9S6Q9nCn9LifIJt88hBBCNEyVy82qLdl8szKTrOwShvfpxEPXDKNH59Yx4FwcH0m4moDZZObWE67n1Q3v8NjKZ5k28Gq6BMf5OiwhhBBtQGmFk8Vr9/L96iwqnS5OO6ELt148kIgQf1+HJpqQJFxNJNw/jNsH38gHeh6vbnib/zvxbizm1vVYrhBCiNYjO7+M71ZlsXT9PsKD/ThvZA9O6h+Hv5/87WiPJOFqQjazlSt6T6SosgSL2UJW8V7igzvLuC4hhBBA3eOzbji/HwNTojDLpNrtmiRcTcxkMhHmH0KVu4pXNrxNp6AYpvS9nEBbgK9DE0II4SMej4c1W3P5cvkuMmV8VockCVczsZqt3DH4Rl7Z8DaPr3qOaQOvJi6ok6/DEkII0YI8Hg9rt+Uyf+lODuSXc/rgLtwi47M6JEm4mlGEPZw7Bk/nff0pr6e9x33Db5fuRSGE6AA8Hg9r041Ea19eKWcM7sqdk7oTGujn69CEj0jC1cz8LDau7HMpJc5SzCYzqw+so1tIF2IDo30dmhBCiCbm8XjYsOMgX763hox9RfxpcBfuuCSV0CBJtDo6SbhagMlkIsQvGI/Hw285G3hr0/uM6jKCcxLOIMQv2NfhCSGEOE4ej4eNOw/y2dKdZGaXMPakBG66oB9hwdJ1KAztJuH69tfddI0Npm9CpK9DOSKTycR1/SezNT+deelfMnP5Y9w8aCqJYT18HZoQQohG8Hg8bMrIZ/6SnezaX8xpg+K5+aIB9EyMbhUFm0Xr0W4SrtzCCnRmQatOuA7pFZHCX4fewtqcNLoGx+N0OVmy61d6BSoZ4yWEEG3E5ox85i/ZwY59RZyaGs/0Cf1lMLw4onaTcA3qGc2zH6+n0unCz9b6J40zm8wMjh0IwO6iLF5f/wFhtlAmpIyjb2QvTDIfixBCtEoZ+4v5YNE2tmUVMio1nmnn9yMy1O7rsEQr124Srl7dwrFYzGzKyGdQStsakN49tCvPjfs7/139Ba9seIs+kT25YcA1knQJIUQrkl/s4NPF21mWtp+R/Toz54Y+RIfJHIuiftpNwmW1mBmQFMnabbltLuECCPYLYkLKuZzadSQZRVmYTCYyijIJtgURFdD6u0mFEKK9cjhdfPPLbhb+kkFCpxAevGooiXGhvg5LtDHtJuECGJQSzQeL0nF7PG22REKkPYJIewQAy/etYvneXzkxbgj9o/rQKyIFu1XGBwghREtwezys2LifT37agdVi4rpxfRmiYqT3QTTKMRMupZQZeBFIBRzAdVrr9DrW+RKYr7V+WSllArKAbd5Vlmut71NKDQOeBEzAfmCy1rqiqU5mQHIU//5iM7v2FZMU3/a/fVzWawIDo/uyfN9K3t78IcM7D+bSXhewuzgLm9lG58BY+cUXQohmsDWzgPd/2MaB/DLGn5TIGUO6YrPKQ02i8erTwjUBsGutRyqlRgBPABfUWmc2EFHjdTKwRms9/tACbxL2KjBRa52ulLoO6AHo4zmBmoLsNnp1C2Ntek67SLhMJhN9oxR9oxQut4tKdyUAy/euYvGeZUT4h9MvSjEodgB9Inv5OFohhGj7sgvK+fjHdNZszWX0CfHcfmmqzA4vmkR9Eq5TgK8BtNYrlFJDa76plJoIuA+t4zUE6KKU+hEoB+7wLs8D7lBK9Qe+1Fo3WbJ1yKCeMSxdv4+LTk1u6l37lMVsIcBsDM68TE3gnIQz2HxQsynP+K9PZC/Scjezr/QA/aJ6ExfUSVq/hBCinsoqqvhi+S6+X5VJnx6RzJo6nC7RQb4OS7Qj9Um4QoHCGq9dSimr1rrKmzhdDkwEHqqxzj5gjtb6I6XUKcC7wO3AScDNQDrwhVJqldZ60ZEOHBERiNXasCkeTh/eg/d/2IbbYqFTZGC9tomJaR3V2hsSRwwhpHSNZzx/ql7mV25ifWYan21fSFRgBKMTTmTSgNqNkU0bR3OSOA4ncQjR9FxuN4vX7mXekp2EBflx68UD6Z8U5euwRDtUn4SrCKh5hzVrrau8P18FdAEWAQlApVJqF7AYqALQWi9VSsUDB4F0rfVmAKXU18BQ77Z1ys8va8CpGKxAl+ggFv2yizOHdjvm+jExIa1iNuCmiKNXQG/uOqE3RZXFbMzTlFeWkZNTTFruZjYf3MoJsQNJCutx1MlV29PnIXG0zTgkoRMtZfeBYt5YuIW8ogouPDWJU1PjsJhlnJZoHvVJuH4GxgMfesdwbTj0htb6nkM/K6VmAvu11l8rpR7F6D58TCmVCmQC24FgpVSKd9D9KOC1JjuTGlJTolmbnluvhKs9CvULYWTc7z2//hY/cssP8uxvrxDiF8ywTicwIeVcH0YohBC+46xy88WyXSxckcGIfp24+8+DCLLbfB2WaOfqk3DNA85SSi3DeLpwilLqTozWqs+PsM0/gXeVUuMwWrqu0VpXKqWmAv/xDqBfprX+sgnO4Q8G9Yzmm193U1ZRRaC9Xc180Sg9I5LpGZFMmbOcDbmbKHAYPcRbDm5jQ+4mBsemkhjWXcoKCSHave17C3lj4RYclVXcNlG6D0XLOWY2orV2AzfWWryljvVm1vg5HxhXxzqLgOENjrKBkuJCCbJbSduZx/A+nZr7cG1GoC2AE+OGVL+2mq3klufxzG9zCfELZkinVKZFT+JgRT7rczdRUVVBufe/8UlnE+IXzHO/vUphZRHlVRVUVFVwZvfRjE08ky92fENGURaJYd1JDOtBQmh3AqxS6kII0To4nC7mLd7B96uyOO2EeC4enUyAv3whFy2nXV5tZrOJgd5uRUm4jiwlPJGU8MTqlq/c8jxMJhMFjkJ+3b+GAIudAKvxn9vjBuCE2AFYTBYCrHbsVjuxgcas/r0je+H2eNiWv4Pvdv9Et+B47hxyE3tL9pNRlEliWA86BcqEgUKIlrclI583v9qCyQR//fMgVPeIY28kRBNrlwkXwAkp0bz25WaqXG6sFukqO5raLV9JYQncM/SWOtc9pcuIOpcfSt4AXG4XJU7jgYfs8ly+yVhETnkegdYAksJ6MG3A1ZhMJkqdZZhNZjweDx48BFjtWM1WCh3FUFpJbnkJHo8Hu9WfEL9giitLKKosJsI/jEBb/Z5AFUJ0XOWOKj76MZ3F6/YxZng3JpySiJ+tYU++C9FU2m3C1TchEqfLTXpWIb17yLeZlmQxWwjzN540GxTTn0Ex/SmuLGFX0W6yy3KxmC1kFGXy2KrnDtvu9hNuoGdEMs/+Npf9ZdnVy0+KG84VfSby895fWbDDmO6tc2AsKeGJTFIX4cEDIGPQxB8cq1KGUuoujKlt3MAjWut5SqkAjKlsYoFi4GqtdU5zV8oQTWv99lze+loTZLfywFVDpPah8Ll2m3D5+1no0yOCtem5knC1AiF+wQyI7lv9umtwPLNG/g0AEybMJjPBfsEA3DF4OlFRQRw8WIYJE1azcZme1X00Z3QbRU55HjsLM8h3FGIymdhesItX1r9VPX4sKawHiWEJ2Mzt9vIW9XfEShlKqXDgNiAFCALWYjwkNB3YoLWeqZSaBDyolLqdZq6UIZpGUWklry7YxK+bD3DeSQmMG9lDejlEq9Cur8JBPaNZuy0Xj8fj61BELRazheiAKKIDoogKiCTCHl6dIAX7BRFqDyHIFkigLQA/i616G5vFRnxwZ07uciLnJY0BoEtwHFf2vZT44Dg2H9zKi+veoMxZjtvj5pNtC1h1YC05ZXmUV1VUj0UTHcZhlTIw5v47pBTIwEi2gjBauQ7bBvgKOBPoxe+VMn4CIpujUoY4Pqu2ZPOXxxax/2ApM6YM44JTEiXZEq1Gu24CSE2O5u2vNXvzyqREQzsWYLUzILpvdQuay+3CYrZQXlVOoaOIz9IXku8oAGBKv8sZ2mkQb2z8D1kl+wiw+GO32kkJT+KchNPJKMokLXczdqsdu9Wf3iQS6ZHB/m3YEStleF9nApsACzCnjm2KgTAgmgZWyoDGVctojNYyWayv4qh0unjlsw0sWpXJ5HP6cMGpSVhaQaLVGv5dWkMMIHFAO0+4IkL8SYwLYe22HEm4OhCL2fgDF2AN4Nr+VwBQXFlCWVU5od5uy5PjT+RgRT4VVQ4qXBVE2sMBKHOWs7s4i3Lv8s+2L+QfI+/DarZysCKf2MAY35yUaKyjVcoYC8QBid7X3yilfq61TQhQgNG61aBKGdC4ahkN1ZGqENQlO7+MF+elUVHp4oErhzCkf3yH/jxaWwwdLY6jJXTtOuECGJQSzbr0PMaNTPB1KMKHQvyCCfEmWwC9Iuoubt4nqhd9onpVvw6L8Kcw38HW/O0889tcEkK7M7zzYIbEphLsJ0l8G3DEShlAPlAOOLTWHqVUARDu3eZc4FeMpGwJsIMWqpQh6m+1zub1hZvpmxDJlLF9ZKJr0ar5vs21mQ3qGcP2PYUUlVb6OhTRBvlZ/QAjQZsx4h76RvZi0e7F/N/yOThclbg9bpwup4+jFEcxD6jwVsp4CmMM1p1KqfO11kuAlcAKpdRyYCvwHfAS0E8ptRSYBszSWlcChyplrAQym6tShji2Kpeb/36/jZfnb2TCKUncNKG/JFui1Wv3V2jXmCAiQ+2s257LqIHxvg5HtGGxgdGMSxrDuYlncaAsB3+LH5sPbuW1tPcYHDuQ4Z0HkxyW0O7Ge1VUOSiqLMbhclBuC6Gs3EWEPaxNTMNxrEoZWusZwIxa75cBl9SxrxaplCGO7mBRBS/NTyO/2MG9VwwmuUuYr0MSol7afcJlMpkYlGI8rSgJl2gKJpOJzkGxAKSEJzG5zyX8un8Nz/72ChH2cB4YficVrgqW712Jy+PC5XHjcrs4Of5EYgKj+HLnd+RXFBjvuV2khCdxateRbMjdRFruZkL8Qgj1CybEL4RBMf3x4KGsshyPx9OgZM7tcVNWVU5pZSkVLgc9QrtR5ixn+b6VlFWVU1FVQYXLweguJ9E9tCvvbf6InUW7vePaHPSLUkzpdzm/7F/Nh1s/O2zfz542h3JXOfcvnY2/1Z8Ai/GQwbjEMfSP7sOizCXklOVi9z7QkBTWo0n/DUTHtH57Hv/+YhNJ8aHcNjGV4AApOC3ajnafcIExPcRzn66n0umSWYZFk7KZrdWTu5Y6y0gv2ImfxUaho4it+dsxm81YTBYsJgtOt9H16PF4sJgt+Jv8sJgs1WPBLCYLLo+bzOIsiipLcLqdnBA7gJyyPG758TGsZishtmBC/UKY2Gs8SWEJLN2zggNlOZQ6yyh1lpIclsiYhD/xw+7FzEv/snpSWJvZxlOjZ+PyuFiXk0agLQC7JQC71b+6papfdB+SwhOxW/yxW/yJsBstByPihjKs0yD8Lf5ERQeRud+YvNaGjZtSp1Lhqqh++CA6wCgEbDaZqXQ5KaosptRZ2tL/LKKdcbndzF+6k69W7GbCqETGjuiBuZ21JIv2r0MkXKp7OGaTic0Z+aSmRPs6HNFOBdkCSY3pB0BMYBS3nHB9nesdmj+str5Rir5R6g/Lo+wRPH3uTDL2H6CospjiyhLC/IxkaF/pAUqcpQTZAomyRxAf3BmAwbEDSQlPJMgWSJAtELvFjslkIsQvmDuH3FTn8QfF9K9zub/FDyzGWDabxVb98IHVbKVnRFKd25zW9eQ6lwvRUIUlDuZ+vpF9eWXcPUnqIIq2q0MkXFaLmQFJUaxLz5WES7Q5FrOFziGdsFX8sX7kJb0uqHObCHs4Ed6pLoRoq7Zk5PPy5xvpEh3EzGuHExbk5+uQhGi01j/qtYkM6hnN2vRc3DLrvBBCtGpuj4cvlu3iiQ/WMjo1nrsuGyTJlmjzOkzCNSApiqJSJxn7fT/5mhBCiLo5nC5e+HQD367M5NaJA7nw1CTMZhmvJdq+DtGlCBAcYKNn1zDWbsuVqvFCCNEKFZVV8uzH6yl3VPHQ1UOJDg/wdUhCNJkO08IFv3crCiGEaF0O5JfxyDursVrM3H/lEEm2RLvTsRKulGgys0vILSz3dShCCCG8tu8t5OG3V9OjUwh3XZZKkF3m1xLtT4dKuDpFBhIXFci69DxfhyKEEAL4bVsOj//nN04ZEMcNF/TDZpW5EkX71KESLpBuRSGEaC0WrcnixXlpTDwtmUtPT5HJTEW71uESrhNSYtiSkU+5o8rXoQghRIfk9nj46H/pfLAonRsv6M+ZQ7v5OiQhml2HS7iS4kMJtFtJ23nQ16EIIUSH46xy8+8Fm1i8di9/nXQCQ1SMr0MSokV0uITLbDYxMDmKtdtyfB2KEEJ0KGUVTp76cC3pewq5/8ohpHQN83VIQrSYDpdwAQxKiWH99jxcbrevQxFCiA7hYFEFc95dQ0WliweuGkpcVJCvQxKiRXXIhKtfYgQOp5v0rEJfhyKEEO3e7gPFzH57FVFhdv52+WAp0yM6pA6ZcNn9rPRNiJCnFYUQoplt3HWQf763htSUaG65eAD+fjLtg+iYOmTCBcYkqL9ty8UjxayFEKJZrN2Wy9MfruPcET246myFxdxh/+QIcexaikopM/AikAo4gOu01ul1rPMlMF9r/bJSygRkAdu8qyzXWt9XY/1XgINa63ub5jQaLjUlmre/0WRll2CXe4AQQjSpjbsO8uJnaVx6egpnybQPQtSrePUEwK61HqmUGgE8AVxQa53ZQESN18nAGq31+No7U0rdAAwAfmpcyE0jIsSfHp1D+HXjfk4d0NmXoQghRLuyNbOA5z5ZzwWnJEiyJYRXfdp2TgG+BtBarwCG1nxTKTURcB9ax2sI0EUp9aNSaqFSSnnXPQk4EZjbBLEftxNSovll435fhyGEEO3Gzn1FPPPxOs4a2o1xIxN8HY4QrUZ9WrhCgZqP87mUUlatdZVSqj9wOTAReKjGOvuAOVrrj5RSpwDvKqXOB2YAFwKX1ie4iIhArM1YV+vMEQl8/sSP5JY46ZMY2WzHqa+YmBBfhwBIHLVJHIdrLXGI1icrp4QnP1jLyf3juOjUJF+HI0SrUp+EqwioeYc1a60P1cW5CugCLAISgEql1C5gMVAFoLVeqpSKx0iyooGFQGcgUCm1RWv95pEOnJ9f1oBTabhAq4nzRiXx2DsrmXXtcAL86/NxNI+YmBBycop9dnyJQ+JoLXFIQtc27ckp4V/vr2WIiuHPZ/bEJHURhThMfboUfwbOBfCO4dpw6A2t9T1a6xO11qcBbwJPaq2/xmjJut27TSqQqbV+Rms9xLvuP4H/HC3ZailXn9sXu5+F/3y31dehCCFEm5RbUM6DL/1Mnx4RXHV2b0m2hKhDfRKueUCFUmoZ8BRwh1LqTm8X4ZH8ExitlPoJeBK45rgjbSZ+NgvTxvfjl83ZrNyS7etwhBCiTckvdvCv99eS3DWcqeP6YDZLsiVEXY7Zh6a1dgM31lq8pY71Ztb4OR8Yd5R9vlnvCFtA19hgJp6WzNtfbyE5PpTIULuvQxJCNIFjTWujlLoLYxyqG3hEaz1PKRUAvAvEAsXA1VrrnBrb+Hxam9aiqKySJz5YS0xEAH+7aigFzTwMRIi2TGag8jpzaFcS4kJ57cvNuGUyVCHai+ppbYB7Maa1AUApFQ7cBowExgBPe9+aDmzQWo8C3gYerLHNoWltOryyCidPfrCWYLuVmy8agK0ZH3ASoj2QhMvLbDIxdVwfMrNL+PbXTF+HI4RoGkeb1qYUyACCvP+5a28DfAWcCa1vWhtfqqis4qmP1mExm7jtklT8bZJsCXEsvnssrxUKD/bnmrG9eXl+Gn0TIujeSZ6WEqKNO+K0Nt7XmcAmwALMqWObYiBMKRVHA6e1geaf2uaQlnyy0+F08fS/V+BywyM3nUJI4O+FqFvLE6YSR+uKASQOkITrDwb3iuGk/p2Z+/lGZlwzDD/55iZEW3a0aW3GAnFAovf1N0qpn2ttEwIUAJfQwGltoPmntoGWnTKkyuXm+U83cCC/nHuvGExFqYOKUkeLx3E0EkfriqGjxXG0hE66FOsw6YyeuNwePvpxu69DEUIcnyNOawPkA+WAQ2tdgZFYhdfcBiMpW6K1frY1TmvTklxuN698vpG9uaX8ddIgwoL8jr2REKKatHDVwe5nZdr4fsx5dzUDkqMYmBzl65CEEI0zDzjLO62NCZiilLoTSNdaf66UOhNYoZRyA0uB77z/f0sptRSoxHiKsUPzeDy8881W0vcUcu/kIfIktxCNIAnXESTFh3L+yQm8vnAzf792OKHybU6INudY09porWdgjM2qqQyjC/FI+3yzqeJrK5as38eKTft58MqhxIYH+DocIdok6VI8inEjE4iNCOCNhZvxyFQRQogOKGN/Me9+u5Wrz+lN19hgX4cjRJslCddRmM0mrj+vLzqzgP+t3evrcIQQokWVlDt5Yd4GRqXGMbJfZ1+HI0SbJgnXMcSEB3DlGMUHP2xjX16pr8MRQogW4fZ4+PcXmwgJ9GPS6T19HY4QbZ4kXPUwol8nBvWM5pXPN1Hlch97AyGEaOMWLs9gx94ibprQH5tV/lQIcbzkt6geTCYTV52tKC6v5LMlO30djhBCNKuNuw4yf+lOpo3vS1SYPJEoRFOQhKueAu02rj+vL9/8uhu9O9/X4QghRLM4WFTB3PkbOe+kBPonyZQ4QjQVSbgaQHWPYMzwbrz6xSbKKpy+DkcIIZpUlcvNS/PTSIgLYfzJCb4OR4h2RRKuBrpwVBIhAX68umATLreM5xJCtB8fLkqnoNjBtPH9MJtMvg5HiHZFJj5tIKvFzM0XDeCRd1fz1teaKWN7Y5IbkxCijftl0wH+t3YP900eQnCAzdfhCNFgbo+bKrdRKtXP4kdRZTEFjkIqXU6cLid7qgLoYu1GqbOMtdkbcHqqqHJXUeV2MbTTIKIDIvk240fyKvKpclVR5akiOSyBU7ue1CTxScLVCFFhdu68NJV/vreG0EA/Jp6W7OuQhBCi0fbmlvLmV1v485m9SIwL9XU4ooNzuV2UOEsprCzC6aoiOTyB3PI8FmUupaiymCJHMQ6Xg2v6/Zm4oE48/MuT5JTn4XQbQ31O7zaKi3uO58fMpXyb8SM2sxU/sx9RQRH8bchtlDnLWbxnOVazFavZgtVkpW9kLwiIxOGqxOV24WexEWgOIMgW2GTnJQlXI3WJCea2ian86/3fCA3yY8ywbr4OSQghGqyisooX5m1gcK8YThsU7+twRAexKU+TU55HfkUBRZXF9I7syfDOg/ksfSHf7/4JD0Z1ly7Bcdw//A7cHg/lVeVE2SNICO1GgMVOsC0IgMvUhQD4mW34WWwE24yKCOcljmF80tmYTcboqZiYEHJyiokJjOK+4bfXGdf4pLOb7Zwl4ToOKV3DmD6hP89/uoGQQJvMxCyEaFM8Hg9vfrUFs9nEVecoGR4hjpvL7aLYWUK4fxgFjkIWZy2nJL2IvQXZ5FYc5KaB19I9tCsLdnwDQIQ9nDC/EAKtRo3Ok+KHMzh2IKH+IYTYgrGYLQDEBkZzdd9JdR4zJTyxzuWHtm0tJOE6Tqkp0Vwztjevf7mZ4AAbA+QxaiFEG/HD6izWb8/joWuG4W9rXX+cROvj9rgpriyhwFFIgaOQUL8QEsN6sHL/b/y89xdyyw9S4CgkyBbIo6Nm4HK72Fu6j64RnencKY4oeyTRAZEA/G3YrXUeIzYwuiVPqUVJwtUETh4QR3GZUXPsr38+geT4MF+HJIQQR5W+p5APFqVz4wX96BzZdONURNtW5ixj88GtFDiKKHAUku8oZGzCGXQJjuORX59iX+kBTJgI9Qvh5C4nkhjWgzD/EPpGKaLsEUQFRBJlN5KqqIBIbhw4pborr6OThKuJnHNid4pKK3n6w3XcN3kI8dFBvg5JCCHqVFRWyUufpXHm0K4MUbG+Dkf4gNPlZG/pfnYXZ5FZvIfsslxuO+EGKlwOPtv+FRH+YYT7hxHpH47VbKQKU/tPxm7xJ9Qv5LDuul4RKfSKSPHVqbQZknA1oYl/SqaorJInP1zL/ZOHEBkqJTGEEK2L2+1h7vyNxITZuXi0PGHdEVS6nOwp2Utm8R4sJgsndzmRFftX8+HWz+gcGEv3kK4MihmA2+Mm0h7BP066r879xAV1auHI2xdJuJqQ2WTimrG9ef7TDTz54TruvWKwzGcjhGhVvl+dRVZOCbOuHY7VInNftzelzjL2lOwlxC+EmJgQPtw6nyV7lgMQH9SZAdF9ABjeeTAndh6Cn0X+RrUUSbia2P+3d9/hcVXXwod/M+pdoy6NZVV7y1Zz78Y2GJtmSmgOxZiSBEghwL0kIRDIvQQSUghJvpAAIRAcEnAuxFTbgE1xo7hgo7JtWcWy3GRp1FDXzPfHjIxQ1GxNk7Te59HjmTn7zFlzfLS1Zp9dfH2M3HZpDr/6524e/9dn/NfKqdIZVQjhFSyNbbzyYSmrlikiQwM8HY4YBqvNysmWWiIDwvH38eevBS9wsK4cS1sdfkY/Lk5fTl5qJnMSpjM7YRpJIQn49UiuAnz8PRj92CQJlwsE+PlwxxX2iVGf+PfnfOdrufJNUgjhcS9uOkBqfBhzsuXW0EjSae3E1+hLfVsjb5W/Q1XTEaqajtLW1c4dU7/JRFMm6RGp5MVMxhyaRFxwzKm5p8aHj/Nw9KKbJFwuEhrkx11X5fPwmp389c1ibr5okqxNJoTwmILyWnbqah68aZbMt+XlGtub2G8pobS+gtL6Co43n+CXY9KzWAAAIABJREFUC3+Kn9GX1s428mNzuDBtGebQRML87ZN8LnLS8jPCdQZNuJRSRuCPQD7QBtyitS7po8wbwDqt9Z+UUgbgMHDAUWS71vpHSqmvA98HOoF9wO1a61G7AnRUeCB3Xz2FR9bsYu3mEq4+e4KnQxJCjEEdnVbWbNzPspnJmGUEtVfptHZS2XiEsoYKuqxdnJuyGG0p4eUDr5MekcLM+CmkRaRgMBgI9gtidXbfk38K7zeUFq5LgUCt9Vyl1Bzg18Alvco8BJh6PM8AdmmtV3S/oJQKcpTL1Vo3K6X+AVwEvDqcD+DtEqNDuOPKPH75D/sSQOfPTvF0SEKIMWb9x4fo6OxixfxUT4cy5jW0N9LR1Ul0kIm3yt5hQ8UmumxWxoUmkR2dBcC0uDymx+VLS+QoM5SEawGwHkBrvUMpNaPnRqXUFYC1u4zDdMCslNoMtAB3Ym/tmqe1bu5x7NbhhT8yZCRF8J3Lcnn8X3vp6rJx4dwU+UUSQrhFdV0Lr28r55srsgn0l14knrCn+nMKa4o5UFfKieaTLDTPZaW6jOyYLDIj0xgfnvyVTuzd/a/E6DKU375woL7H8y6llK/WulMplQNcA1wB/KRHmaPAI1rrtUqpBcAarfVM4DiAUuq7QCjw9kAHNpmC8fV1/Qi/2Ngwlx9jSWwYJlMwDz/7CV+0d3Hb1/Lw6dWR3h1xDIXE8VUSx1d5SxxiaF54ez+TUkxMmzh6l0zxFjabjZpWCwfqSjlcWklORDaToidSWFNMe1cnS8cvIjMynbgg+//F+DDp0D6WDCXhagB61rBGrXWn4/EqwAxsAlKBdqVUOfAB9n5aaK23KKWSHP26DMCjwETgcq21baADWyzNA212CncuOWA2BfHDa6fx27WfUXWikdsuySEowNftcQxE4pA4PB2HJHTOs/tANQXlFh66RTrKu4LNZuNEy0miAiLxMfrwvzt+xYmWk8QERpGTqAj0tU9+fU3WFR6OVHiDoSRcW4EVwEuOPlz7ujdore/pfqyUehA4prVer5T6BVADPKqUygcqtdY2pdST2DveXzqaO8sPJDkulPtWzeC3az/jF3/fxR1X5mMKk/lwhHCFwQb9KKXuxt5KbwUe1lq/4uhvugaIAxqBG7TW1SNt0E9bexcvvH2Ai+amEGeStRKdpb2rg73Vn7Ovpoj9loM0tDdy57TbyIxM48qJl5AYEo8pMNJrviQJ7zGUG8WvAK1KqW3AY8CdSqm7lFIXD7DPz4FFSqn3gd8Aq5VS04CbgVxgk1LqPaXUZcOMf0QyhQXww2unER7iz8+e/5TD1U2eDkmI0erUoB/gh9gH/QCglIoE7gDmAsuA3zo23Qbs01ovBP4G3Ndj0M8SrfV8IAL7oB+v9fr2cnx8DJw/Z7ynQxnxLK11fHB4O13WLtqt7bxy8E38jX5cMeFiHp5/P5mRaQBMjlaYAiM9HK3wVoO2cDm+wd3a6+XiPso92OOxBbiwj7eTnoAOQQG+fO+KPJ7foHlkzU5+vHo2SSZZe1EIJxto0M8XQAUQ4vix9tjnUcfjt4D7sbeOjZhBP0drvmD9R4e448o8/NzQD3Y0amxv4oOq7eyrLqCy6QjxwXFkRyuig6J4aN69cotWnDYZsuJBvj5GVp+fRUxEIA8+vZ0bzstifm6ip8MSYjTpd9CP43klUAj4AI/0sU8jEOH44nlag37AMwN/bDYbv/3XXubkJLJkVqrLj91fHJ50JnF0Wrsoqj7AvuPFrMy9GJ/WLg4Wl7IoYzYzzPkkhZ3+7PzecD68IQaQOEASLo8zGAysmJ9GWrKJ3724m5r6VlbMT5VvT0I4x0CDfs4HEoE0x/MNSqmtvfYJA+rgVH+wIQ/6Ac8M/NlReAxdYeFn35jt1j5E3tJn6XTjOP7FCd4sf4eCGk2ntZOsqAlUHq0m2C+Y7+V9y16oFapbT++zecP58IYYxlocAyV0knB5iSXTk/Gx2fjDy/uorm/hhvOyZP1FIYav30E/gAX7PIFtjkE9dUCkY58LgI+xJ2UfOsr/GS8f9NPc2smL75ZwyYI0osKli0JfOqydFNVo9tcd5PLMFfgaffE1+HL9pKuYFDUBf1nUWbiIJFxeZFKKiXuvs08b8fjaz7j9stxT00YIIc7IK8C5jkE/BuBGpdRdQInW+lWl1FJgh1LKCmzBfptwC/CcUmoL0A5c02PQz4fYB/0APK61fsX9H6l///6wlNBgP5bOkPmdejv+xQk2VGzms+oCDAbIi8mm3dpBdFAU10++ytPhiTFA/pp7GXNsKD9eNYPH1+7lkTU7+f6V+fJNVYgzNNigH631A8ADvbY3A1f2eu0YXj7o59DxRjbtquKea6ZK6zjQZe1CW0o4WF/OivTl2LBhtVlZnb2SrKiJ+Bnlz59wL7nivFBkaAA/uHYqf1pXwEN/+5TvX5nP+Hjv6HAohPA+VpuN5zdo5mbHMzF5bE9LcKTxOGuL32JP9T46ujrIjZlMR1cHCSHxrM7+uqfDE2OYJFxeKtDfl+9enssLbx/gZ8/v5OqzM1ky1Syd6YUQ/2HL3qMcrWnmu5fneToUj2jtbKWgRjM9Pp+2zna+6Ghmpfoa2dFZX1mjUAhPkoTLi/kYjVy/XDFhXATPb9R8XlrLjRdkERYsFYgQwq6+qY21m0u4fHEG4SFjq25o6viC9yu38t7hrQT7BTM5eiJpscl8I/d6T4cmxH+QhGsEmJOdQIY5gidfK+Anz3zMNy6azOTUKE+HJYTwAn97s4jYyCAW5Sd5OhS3OtlSy88+/g3RgSaumngp0+Ly8DHKJK/Ce0nCNULERtoXvn51SzmPvfQZy2Ylc9nCdOkcK8QYVlJVzzufHOLH10/HaBz93Q1qWmp559D7nJuymOhAE7fmrmaCKR2jQepB4f0k4RpBfIxGLjsrncmpJp56vZCicgvfujib+ChZmFaIseilzSUsn5NCWmK4p0NxqWNfnGBjxWY+Ob6bjIhUWjvbMAQaUFGZng5NiCGTrwUjkBpv4qc3zbIvCfTXT9i67yg226CTXgshRpGmlg4OHq7n/Lmpng7FZWw2GzabjT/ve5amji/4/tRb+f60W0kKTfB0aEKcNmnhGqFCAv247dIcPtx7lOc3avaV1rBquSI40M/ToQkh3KC4wkJIkB8pCeHU1DR5OhynKq2vYH35u6RHpHJe6tncM+N7BPnKfIRiZJMWrhHMYDBwVn4SD6yeybHaZh545hNKDtcPvqMQYsQrqrAwKcU0qvpuHawr53e7n+SxXU8Q6hfClNgcAEm2xKggCdcokBgdwo+vn8GMrFh+8cIuXt1SRpfVK5d6E0I4SWGFhUmpJk+HMWw2m43GdnsL3cH6MqIDo3hgzn+zavLVJITEeTg6IZxHbimOEn6+Rq4+ewLZaVE8/XoRBeW13HThJOJN0qFeiNGmtqGV47XNTEoZuQmXzWajsHY/68vfobmzlftm3cWylCWeDksIl5EWrlEmJy2a/7lpFqFBftz/9Mes21JGR2eXp8MSQjhRUYWF6PAA4iKDPB3KGalsPMIvP/0DT+17juSwcXwn/2ZZRUOMetLCNQqFh/jz3cvz2HPgJH9/ez/bC45x/TJFdppMlirEaGDvvxU1opIUq83KfstBlCmTYN8gMiJT+VbeDUQEjO4pLYToJgnXKDZlQgyTUky8tq2c3679jGkTY1l5zgRMYQGeDk0IcYZsNhtFFRauWJzh6VCGxGqzsvvEXtaXb6KmtZZ7Z91FTFAUl09Y4enQhHArSbhGuQB/H65YnMHcnATWbND8+KkdXLownXOmm/Exyh1lIUaaY7XNWBrbRkT/rZbOFn6184/UtdazOHk+S5IXEOoX4umwhPAISbjGCHNMCPdcM5XtBcd4cVMJ2/Yd5frligxzhKdDE0KchqIKC0kxIUSGem9LdUN7I13WLkyBkZyXcjbZ0VkE+43M/mZCOIs0cYwhBoOBeTmJPPzNOaSbI3hkzS6eW19MU0uHp0MTQgxR9/xb3shqs/Jh1Xb+Z8cvef/wNgBmJkyVZEsIJOEak0IC/Vi1XHHv9dMpP9rIvU/uYMteWR5ICG9ntdkorrAw2QsTrkN1Vfxm5x959eB6Lsu8kIszzvN0SEJ4FbmlOIalJ4Vz/w0z2LTrMP94dz9b9h7heyunEew7ckY+CTGWVB5vormtEzU+0tOhnGK1WTEajNS21BMXHMu38lYT5h/q6bCE8DqScI1xRqOBpTOSmZEVxz/fPcD3fr2ZOdkJXLIgjdgROsePEKNVYUUtqQlhXrNm6t7qAv598C1uz7+JKeMnY/ZN9nRIQngtSbgEAJGhAdx6SQ6153bwzKufc++TOzgrP4mL5qXKNBJCeImicvv8W55maa1j7f51FNRqlqcskbm0hBgC6cMlvkKlRPFfK6dy99VTqDzRxA//vJ0XNx2gsbnd06EJMaZ1dlnZf7jO4+sn2mw2ntj7V9q62vnxrDu5IO1c/Izy3V2IwchviehTVoqJH103jX2lNbz8finv7TnC8pnJLJs5nuBAuWyEcLfSIw1YrTDBQ1O5HGo4zLHmE8xKmMa3828h3D90RM10L4SnDfqXUyllBP4I5ANtwC1a65I+yrwBrNNa/0kpZQAOAwccRbZrrX+klFoB/AToBJ7RWj/lvI8inM1gMJCXEUNOejQ7dTX//rCUd3ce5vw5KZwzbRwB/j6eDlGIMaOwvJZMczj+fu7/vdt65CNe0v9moXkusxKmEREQ5vYYhBjphtJUcSkQqLWeq5SaA/wauKRXmYeAnu3cGcAurfWptRuUUn7AY8BM4Atgq1LqVa318eF8AOF6RoOBmVlxTJsYw46C46zbUsbGTyq5aG4Ki6aY8fOVO9NCuFpRhYWc9Gi3HrPT2snaA6/y0dGdXDfpKmYmTHXr8YUYTYaScC0A1gNorXcopWb03KiUugKwdpdxmA6YlVKbgRbgTiAAKNFaWxz7bQHOAtYO90MI9/AxGpmfm8jsyfF8+NkRXt1WzoaPD3Hx/DTm5SbIUkHC6wzWQq+Uuhu4Bnsd9rDW+hWlVBCwBogDGoEbtNbVnmyhb23vpPRIA1cuyXTXIQHotHZR11rP3dNvJznM7NZjCzHaDCXhCgfqezzvUkr5aq07lVI52CurK7BXRN2OAo9ordcqpRZgr7zu7PU+jcCAnRFMpmB8fV3ffB4b6x3N4yMpjqsSIrjk7Im8ubWMte8e4I0dFaxYmMGy2eOdNmR9JJ0Pd5A4zki/LfRKqUjgDiATCAH2AK8AtwH7tNYPKqVWAvcppf4LD7bQ76+sx8/XSFqie859WX0FhxqrWDRuHrfl3+iWYwox2g0l4WoAev6WG7XWnY7HqwAzsAlIBdqVUuXAB9i/BaK13qKUSsKeYPV8nzCgbqADWyzNQwhveGJjw6iubnT5cUZrHAuy45kxIZote4+y7v0SXthQzKIpSSydPo6o8EC3xeEqEof743ByQjdQC/0XQAX2ZCsEeytX9z6POh6/BdwPTMKDLfRFFbWo5Ei3tCJ399danLzA5ccSYiwZSsK1FVgBvOT4hrive4PW+p7ux0qpB4FjWuv1SqlfADXAo0qpfKASKAQmKKWigCbsldWvnPVBhOcE+vuydEYyZ08bx6791az/+BBvf1LJrEnxLJ+VzPj4EdUiIkaXflvoHc+76yYf4JE+9uluie/9PoO20IPzWukPHG7g7JnJ/SajzkhSO7s6+evul3i/fAe3z17FgpRZp/0e3tL6KXF4VwwgccDQEq5XgHOVUtsAA3CjUuou7N/2Xu1nn58Da5RSF2Jv6Vqtte5w7LcB+/xfz2itq4b/EYS3MBoNzMiKY7qKpaSqnvUfHeKnz37CpBQT580aT3ZalAwjF+42UAv9+UAikOZ4vkEptbXXPt0t8b3fZ9AWenBOK31TSwelR+pZHa36bF10VqtjR1cHJxvruWva7SQHm0/7PcdSK+xIicMbYhhrcQyU0A2acGmtrcCtvV4u7qPcgz0eW4AL+yjzGvDaYMcUI5vBYGDCuEgmjIvkeG0zGz+p5Pcv7yPOFMTymeOZPTleRjYKd+m3hR6wYB/U06a1timl6oBIxz4XAB9jT8o+BIrwUAt9cYWF8GA/zLEhLnn/svoKSurKODdlMbfkXOeSYwghZOJT4WLxUcFcv1xxycI03ttVxdr3Svi/Dw6ydPo4Fk81E+Ila8KJUWvAFnql1FJgh1LKCmwB3nb8+5yjn1Y7cI0nW+gLKyxkpZhc0jq8teojXtr/bxaNm4/NZpMWaCFcSBIu4Rbhwf5cvCCN82aPZ3vBMTZ8XMlr28qZMzmexVPNpCbIWmzC+QZroddaPwA80Gt7M3BlH+/lkRb6ovJazps93qnv2WntZO3+dXx0bJfMryWEm0jCJdzK38+HRVPMLMxPoqCsls27qvjf5z4lNSGMxVPMzJocT4AHZtIWwhvVNrRy3NLCpFTnLlhtwECHtZO7p3+b5LAkp763EKJvknAJjzAaDOSmR5ObHk1tQyvv7znCyx+W8uKmEublJvC1sycSKN28xBhXWG4hJiKQuMggp7xfa2crO47tZJF5HqsmX+2U9xRCDI0kXMLjosIDueysdFbMT2XPgZNs3l3Ft3+5CZUcyeKpZqZNjMXXR7IvMfYUVViYlGIavOAQdFg7eXLf32jq+II5CTMI9A1wyvsKIYZGEi7hNXx9jMzIimNGVhztGHj53f08v0Hzwtv7WZifxKL8JGKc9E1fCG9ns9koqqjlqrOHv5xPl7WLZwteoLbVwl3Tb5dkSwgPkIRLeCVzbCgrz5nA185K55PiE7y3u4o3t1eQmxHNwrwk8jKiZWoJMaodq22mrqmdSSnD77/1QdV2yuoPcdf02wn3944JKIUYayThEl7N38+H+bmJzM9N5NDxRt7bXcUzbxZhNMDMSfHMzY4n0xwhw9nFqFNYbsEcG0JEiP+w3sdms7HQPIfcmEnEBDm3870QYugk4RIjxvj4MFadl8XXl07gs5Iathcc49EXdmMKC2BudgJzcxJIiAr2dJhCOIUz+m9trNhMc0cLl2ZeQExQtJMiE0KcCUm4xIjj5+tzqq9XU0sHnxSfYPvnx3htWzlpieHMzY5n1uR4woOH1zIghKdYrTaKKyzcfNGkM36PrVUf8UbpRm7Nv9GJkQkhzpQkXGJECw3yY8lUM0ummjlhaWZHwXHe3XmYf75bQk56FPNyEpiSGYO/zO0lRpCK4420tHeiks+shWvXib38c/8r3Jh9DZOiJjo5OiHEmZCES4wacaZgLl6Qxor5qZQdbWT758dYs3E/z75VzHQVy8yseCanmmSKCeH1iisspCWGExx4ZlX0rhN7WTnxMqbF5Tk5MiHEmZKES4w6BoOB9KRw0pPCufqcTArKatlReJwn1n2Oj8HA1AkxTM+KIzs1SkY6Cq9UeIb9t2paLEQFRnJz9rUykEQILyMJlxjVfH2M5GfGkJ8ZQ3tHFwVltXyqT/DUawUATMmMYYaKIyc9Cj9fue0oPK+j08qByjouOM31E480HeOxXU/w9azLpWVLCC8kCZcYM/z9fJg6MZapE2Pp6LRSUF7LzuIT/OWNIrpsNkfyFUtOerSs5yg8pvRIPTYgc1zEkPepaanlD3ueJi82m6mxua4LTghxxiThEmOSn6+RKZkxTMmMobPLSmG5hU/1CZ59q5iOLit5GTHMzIpjSbjMbC/cq7DcQqY5Ysgtrg2tjfx+z1OkhidzjbpcbiUK4aUk4RJjnq+PkbyMaPIyoulcrig+ZOHT4mqe36B5+vVCJqWYmOK4LWkKkyVRhGsVVVjIyxj6nFlBfoHMSZzJOckL8TFKy6wQ3koSLiF68PUxkpMWTU5aNNcvn0h1UwfvfXKI9R8d4m8bNKkJYUyZYG8ZS44LldYE4VQtbZ2UHW3g6nMGXz/RarOypeojLotZynmpZ7shOiHEcEjCJUQ/fIxGcjNiSAgP4OqzMzla08yekpPsOXCSdR+WERUewJTMWKZMiEGNj5TpJsSwHThch7+fkdSEwdc73FjxHu9VbmH55PluiEwIMVyScAkxBAaDgaSYEJJiQrhgTgoNX7Tz2UF78vX7l/fiYzSQkxbNlAkx5KZHExrk5+mQxQhUWG5BJZvwMQ6cvFc0VPJm2dt8M3cVoQEhtNDopgiFEGdKEi4hzkB4iD8L85JYmJdEe0cXRRUW9pSc5KXNJfzl9SIyzOHkpEWRkx5NSkIYRrn1KIagqMLCgrzEAcu0dbXzbOE/mJ80m5yYM1/6RwjhXpJwCTFM/n4+p+b6ut5mo+JYI5+X1rCvrJZ1W8oJDvR1JF9RZKdFExEiazyK/9TQ3E7liSYmDzLhqY/ByPyk2ZxlnuemyIQQziAJlxBOZDQYSEsMJy0xnBXz02hu7aCw3MLnZTW8/EEpT79exPj4UHLSoslNjyLDHCF9vwRgX84nPMSfpJiQfstUNR0lPjiWpeMXuTEyIYQzSMIlhAsFB/oxIyuOGVlx2Gw2jtQ0U+Bo/dr4SSW+PgYmpZjISY8mOy2K2IhAGfk4RhU5lvPp7/+/rq2ex3f/mUszLmBe0iw3RyeEGC5JuIRwE4PBgDkmBHNMCMtmjaeto4v9lXXsK63hnU8reX6DJjo8gKzxJrJSTKjxkcREyMSrY0VRhYUL5qT0uc1qs7KmaC3m0CTmJM5wc2RCCGeQhEsIDwnw8yE3PZrcdPskl7UNrRQfslB8qI51W8o4Wd9KTEQgWSkmZuUkYjYFycSro1RNfSsnLC399t967/BWKhoquXfWnRgNcgtaiJFIEi4hvERUeCDzchKZl2MfpXayvoXiijr0IQvPv1VEtaWFOFOQowUskqzxJiJDJQEbDSqrm0iICiYmsu8WzU5rJ1/PuhxTYKSbIxNCOMugCZdSygj8EcgH2oBbtNYlfZR5A1intf5Tj9ezgI+AeK11q1JqKfBzoBN4R2t9n9M+iRCjTExEEAvygliQl0hMTCiFJdUUV1jQhyys3XwQS2MbCVHBqPGRZJojmJAcKX3Aehmo/lJKTQF+26P4HOBSQAPPAQagAvim1rpZKXU3cA1gBR7WWr/irDjz0qOZ0Mdi1R1dHdiAZSlLnHUoIYSHDKWF61IgUGs9Vyk1B/g1cEmvMg8BX2kLV0qFO8q29Xj5l8C1QBHwoVIqV2u970yDF2KsMBgMxEUGERcZxFn5SdhsNk5YWig+ZOHA4fpTtyAjQv2ZMC6SCeMimDguknFxIYNOojnK9Vt/aa33AIsBlFJXAlVa6/VKqX8Bf9Jav6CUugW4Syn1B+AOIBMIAfYATku4jEYDIYH/OVnuutK3qG6u4bb8G511KCGEhwwl4VoArAfQWu9QSn2lx6ZS6grs3/jW93jNADwJ3Aus61F8NxAF+AGBQNdwghdirDIYDMRHBRMfFcyiKWYALI1tlFTVc6Cyjm37jvHPdw/g7+dDZlL4qSQsPSmCAP8xtcDxgPUXgFIqBPgpcJbjpcnANxyPtwKPAb/A3toV4vixujZsKKrZz/uHt3HntNtcfSghhBsMJeEKB+p7PO9SSvlqrTuVUjnYm9ivAH7So8wDwBta68+UUj3fax/wOlAD7AWKBzqwyRSMr6/r/zjExg6+bpk7SBxfJXF81WBxxMaGMTE95tTz5tYOdIWFwrJaCstqeOvjQ3R0Wkk3RzA5LYqsFPtPrOn0RkJ6y/kYon7rrx6v3Qys1VqfdDzfA1yM/bbixdgTLIBKoBDwAR4ZysHPtA5raGtizbaXuHzy+czOzBm0vLf8n0gcX+UNcXhDDCBxwNASrgagZ4TGHpXVKsAMbAJSgXalVDlwHXBYKXUzkABsVEpdDPwIyNZaVymlHgXuxn6bsU8WS/NpfZgzERsbRnW159chkzgkDlfEMS4qiHFRZpZNN9PZZaXyRBMHKus4cLie93cdpr6pHVNYABnmCDKTwskYF0FKfFi/k7G643w4uUIcqP7qdi32L43d7gb+oJS6EXgTOAmcDyQCaY4yG5RSW7XWHw908DOtw/ZWFxAbGMPC2AWDnu+Rfo1KHKM7hrEWx0D111ASrq3ACuAlRx+IU32utNb3dD9WSj0IHNNar8fez6H79XJgGWADmhw/AEeB2KF9BCHEcPn6GE/Ngr9sFthsNmoaWjlY1UBJVT07Co+z9r2DGAwGUhPCyDRHkGEOJ8McMZJHQ/ZbfwEopSKAAK11ZY+XzwXu1VprR0f5twEL0AK0aa1tSqk6wCVDBm02G3mx2eTETJIpIIQYRYaScL0CnKuU2oZ91M6NSqm7gBKt9atDPZDWus1ReW1USrUCdcDqM4hZCOEEBoOBmIggYiKCmD05HoC2ji7KjzZw8EgDB6vq2fb5URqaO4gODyRzXAR5E2OJCwtgfHwofm643e8Eg9VfE4HyXvto4O9KqTagAPi21rrDMcp6h1LKCmzBnog51fHmav7y+Rq+O+UbhPmHOvvthRAeZLDZbJ6OoV/V1Y0uD24sNXVKHBLH6bLZbFTXtdhbwY7UU3miibIjDQCMiwsl3dFilpYUTmJ0MEYnTEkRGxs2aua1OJ06rMvaxa92/j+ig6K4OfvaIU/vMdavUYnDu2MYa3EMVH/JxKdCiH4ZDAbiTMHEmYKZm5NAbGwYR47Wceh4E6VHGyg72sAb28s5bmkh0N+H1IQw0pLCTyViUeGBnv4II8YbZW/T0N7Id6bcInOpCTEKScIlhDgtfr4+ZJgjyDB/OVFnU0sH5ccaKDvSQOmRBrbutd+KjAz1Jzc9mtXnZ0kSMYDG9ibeP7yNb+WtIsQv2NPhCCFcQBIuIcSwhQb5kZMWTU6afV3I7g75ZUcbaWnrlGRrEGH+ofx03g8I9QsZvLAQYkSShEsI4XQ9O+SLoZFkS4jRTcYcCyGEEEK4mCRcQgghhBAuJgmXEEIIIYSLScIlhBBCCOFiknD4MQFhAAAEmklEQVQJIYQQQriYJFxCCCGEEC4mCZcQQgghhItJwiWEEEII4WJevXi1EEIIIcRoIC1cQgghhBAuJgmXEEIIIYSLScIlhBBCCOFiknAJIYQQQriYJFxCCCGEEC4mCZcQQgghhItJwiWEEEII4WK+ng7AHZRSs4FfaK0XK6UygWcBG/A58G2ttbVH2SBgDRAHNAI3aK2rXRDHFOD3QBfQBqzSWh/vVX4X0OB4Wqa1vtEFcUwFXgcOODY/obV+sUdZd52PfwIJjk2pwA6t9coeZQ3A4R5xbtda/2iYx/cDnnEcLwB4CCjEzddHP3Ecwo3XRz8xVOKha0N8SeqvAeOQ+kvqr4Hi8Ko6bNS3cCml7gGeBgIdL/0GuE9rvRAwAJf02uU2YJ9j+9+A+1wUx+PAd7XWi4GXgR/0Kh8IGLTWix0/zqqsescxHfhNj+O82GsXt5wPrfVKx7m4DKgD7uy1Swawq0ecw6qsHK4Dahyf7TzgD3jm+ugrDndfH33F4JFrQ3xJ6q9B45D6S+qvgeLwqjps1CdcwEHgaz2eTwfedzx+C1jaq/wCYP0A250Vx0qt9R7HY1+gtVf5fCBYKbVRKbVJKTXHRXFMBy5USn2glPqLUiqsV3l3nY9uPwV+r7U+2uv16YBZKbVZKfWmUko5IYa1wP2OxwagE89cH33F4e7ro79z4YlrQ3xJ6q+B45D6y26s11/9xeFVddioT7i01v8HdPR4yaC17l7PqBGI6LVLOFA/wHanxNH9C6mUmgd8B3is1y7NwK+A5cCtwN+VUsO+BdzH+fgY+G+t9VlAKfBAr13ccj4AlFJxwDnYm8R7Owo8orVeAjyMvRl4uDE0aa0bHb+E/8L+7cbt10dfcbj7+ujnXHjk2hBfkvpr4DiQ+kvqrwHiwMvqsFGfcPXB2uNxGPbm354aHK/3t91plFJXA38CLuzjvvF+YI3W2qa13g/UAIkuCOMVrfXO7sfA1F7b3XY+gCuAF7TWXX1s+xRYB6C13gIkOfpFDItSKhnYDDyvtX4BD10ffcTh9uujjxi86doQdlJ/fZU3XaNSf3mw/uonDm+6PsZkwrVbKbXY8fh84MNe27cCFwyw3SmUUtdhz/wXa61L+yhyE/BrR9kk7Jl472ZqZ9iglJrleHwOsLPXdrecD4el2Jt1+/IA8H0ApVQ+UNnjm9wZUUrFAxuBH2itn3G87Pbro6843H199HMuvOnaEHZSf32VN12jUn95qP7qLw686/oYG6MUe7kbeEop5Q8UYW96RCm1EbgIeAJ4Tim1BWgHrnF2AEopH+B32EdyvOy4nf++1voBpVR3x72/AM864rABN2mtO50dC/ZOg79XSnUAx4BvOmJ02/noQWFv9v3yhS/j+DmwRil1IfZ786udcLx7ARNwv1Kq+97/HcDv3Hx99I7DB8gBKnDf9dHXubgLeMxLrg1hJ/XXV0n9JfVXf3GAl9VhBpttWEm2EEIIIYQYxFi8pSiEEEII4VaScAkhhBBCuJgkXEIIIYQQLiYJlxBCCCGEi0nCJYQQQgjhYpJwCSGEEEK4mCRcQgghhBAu9v8BzK7nXc1rEH4AAAAASUVORK5CYII=\n",
265 |       "text/plain": [
266 |        "<Figure size 720x288 with 2 Axes>"
267 |       ]
268 |      },
269 |      "metadata": {
270 |       "needs_background": "light"
271 |      },
272 |      "output_type": "display_data"
273 |     }
274 |    ],
275 |    "source": [
276 |     "metrics_per_epoch = show_metrics_per_epoch(history, smoothing=True)"
277 |    ]
278 |   },
279 |   {
280 |    "cell_type": "code",
281 |    "execution_count": 17,
282 |    "metadata": {},
283 |    "outputs": [],
284 |    "source": [
285 |     "if USE_TFRECORD:\n",
286 |     "    test_dataset = extract_dataset(test_dataset_path, compression_type='GZIP', \n",
287 |     "                                   shuffle_buffer_size=shuffle_buffer_size, is_training=False)\n",
288 |     "    test_dataset = transform_dataset(test_dataset, num_feature_names, cat_feature_names, \n",
289 |     "                                     target_name=target_name)\n",
290 |     "    test_generator = load_dataset(test_dataset, batch_size=batch_size, is_training=False)\n",
291 |     "    \n",
292 |     "    y_true = get_target(test_generator)\n",
293 |     "    y_score = model.predict_generator(test_generator).ravel()\n",
294 |     "    \n",
295 |     "else:\n",
296 |     "    y_true = df_y_test.values\n",
297 |     "    y_score = model.predict(test_model_input).ravel()\n",
298 |     "\n",
299 |     "dump_pickle(score_path, y_score)"
300 |    ]
301 |   },
302 |   {
303 |    "cell_type": "code",
304 |    "execution_count": 18,
305 |    "metadata": {},
306 |    "outputs": [
307 |     {
308 |      "data": {
309 |       "image/png": "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\n",
310 |       "text/plain": [
311 |        "<Figure size 288x288 with 2 Axes>"
312 |       ]
313 |      },
314 |      "metadata": {
315 |       "needs_background": "light"
316 |      },
317 |      "output_type": "display_data"
318 |     },
319 |     {
320 |      "data": {
321 |       "image/png": "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\n",
322 |       "text/plain": [
323 |        "<Figure size 432x288 with 1 Axes>"
324 |       ]
325 |      },
326 |      "metadata": {
327 |       "needs_background": "light"
328 |      },
329 |      "output_type": "display_data"
330 |     },
331 |     {
332 |      "data": {
333 |       "image/png": "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\n",
334 |       "text/plain": [
335 |        "<Figure size 432x288 with 1 Axes>"
336 |       ]
337 |      },
338 |      "metadata": {
339 |       "needs_background": "light"
340 |      },
341 |      "output_type": "display_data"
342 |     },
343 |     {
344 |      "data": {
345 |       "image/png": "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\n",
346 |       "text/plain": [
347 |        "<Figure size 432x288 with 1 Axes>"
348 |       ]
349 |      },
350 |      "metadata": {
351 |       "needs_background": "light"
352 |      },
353 |      "output_type": "display_data"
354 |     },
355 |     {
356 |      "data": {
357 |       "image/png": "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\n",
358 |       "text/plain": [
359 |        "<Figure size 432x288 with 1 Axes>"
360 |       ]
361 |      },
362 |      "metadata": {
363 |       "needs_background": "light"
364 |      },
365 |      "output_type": "display_data"
366 |     }
367 |    ],
368 |    "source": [
369 |     "ctr = y_true.mean()\n",
370 |     "y_pred = get_y_pred(y_score, threshold=ctr)\n",
371 |     "\n",
372 |     "norm_entropy = get_norm_entropy(y_true, y_score)\n",
373 |     "calibration = y_score.mean() / ctr\n",
374 |     "accuracy, precision, recall, f1 = accuracy_score(y_true, y_pred), precision_score(y_true, y_pred), \\\n",
375 |     "    recall_score(y_true, y_pred), f1_score(y_true, y_pred)\n",
376 |     "\n",
377 |     "confusion_matrix = plot_confusion_matrix(y_true, y_pred)\n",
378 |     "auroc = plot_roc_curve(y_true, y_score)\n",
379 |     "auprc = plot_pr_curve(y_true, y_score)\n",
380 |     "_ = plot_lift_curve(y_true, y_score)\n",
381 |     "_ = plot_class_density(y_true, y_score, threshold=ctr)"
382 |    ]
383 |   },
384 |   {
385 |    "cell_type": "code",
386 |    "execution_count": 19,
387 |    "metadata": {},
388 |    "outputs": [],
389 |    "source": [
390 |     "dump_pickle(os.path.join(MODEL_DIR, '_'.join([model_type, 'metric', train_dataset_type]) + '.pkl'), \n",
391 |     "            (norm_entropy, calibration, accuracy, precision, recall, f1, confusion_matrix, auroc, auprc))"
392 |    ]
393 |   },
394 |   {
395 |    "cell_type": "code",
396 |    "execution_count": 20,
397 |    "metadata": {},
398 |    "outputs": [],
399 |    "source": [
400 |     "test_dataset_type = 'quiz'\n",
401 |     "score_path = os.path.join(MODEL_DIR, '_'.join([model_type, 'score', test_dataset_type]) + '.pkl')"
402 |    ]
403 |   },
404 |   {
405 |    "cell_type": "code",
406 |    "execution_count": 21,
407 |    "metadata": {},
408 |    "outputs": [],
409 |    "source": [
410 |     "if USE_TFRECORD:\n",
411 |     "    test_dataset_path = os.path.join(DATA_DIR, '_'.join([model_type, 'dataset', test_dataset_type]) + '.tfrecord')\n",
412 |     "    test_dataset = extract_dataset(test_dataset_path, compression_type='GZIP', \n",
413 |     "                                    shuffle_buffer_size=shuffle_buffer_size, is_training=False)\n",
414 |     "    test_dataset = transform_dataset(test_dataset, num_feature_names, cat_feature_names, target_name=target_name) \n",
415 |     "    test_generator = load_dataset(test_dataset, batch_size=batch_size, is_training=False)\n",
416 |     "    \n",
417 |     "    y_score = model.predict_generator(test_generator).ravel()\n",
418 |     "    \n",
419 |     "else:\n",
420 |     "    df_X_test = pd.read_pickle(os.path.join(DATA_DIR, '_'.join(['df', 'X', test_dataset_type]) + '.pkl'))\n",
421 |     "    test_model_input = {column: df_X_test[column].values for column in df_X_test.columns}\n",
422 |     "    \n",
423 |     "    y_score = model.predict(test_model_input).ravel()\n",
424 |     "    \n",
425 |     "dump_pickle(score_path, y_score)"
426 |    ]
427 |   }
428 |  ],
429 |  "metadata": {
430 |   "kernelspec": {
431 |    "display_name": "Python 3",
432 |    "language": "python",
433 |    "name": "python3"
434 |   },
435 |   "language_info": {
436 |    "codemirror_mode": {
437 |     "name": "ipython",
438 |     "version": 3
439 |    },
440 |    "file_extension": ".py",
441 |    "mimetype": "text/x-python",
442 |    "name": "python",
443 |    "nbconvert_exporter": "python",
444 |    "pygments_lexer": "ipython3",
445 |    "version": "3.7.5"
446 |   }
447 |  },
448 |  "nbformat": 4,
449 |  "nbformat_minor": 2
450 | }
451 | 


--------------------------------------------------------------------------------