diff --git a/README.md b/README.md index 47c5f59..47fbbb0 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@

MIT License - +

--- @@ -262,6 +262,7 @@ Original implementations are quite complex and not really beginner friendly. So 47. Attention is all you need + Beam Search 48. Fairseq 49. Conv-Encoder + LSTM +50. Bytenet Greedy @@ -362,6 +363,9 @@ Original implementations are quite complex and not really beginner friendly. So 7. Word-wise + Seq2Seq + GRU 8. Character-wise RNN + LSTM + Bahdanau Attention 9. Character-wise RNN + LSTM + Luong Attention +10. Word-wise + Seq2Seq + GRU + Beam +11. Character-wise + Seq2Seq + GRU + Bahdanau Attention +12. Word-wise + Seq2Seq + GRU + Bahdanau Attention ### [Language-detection](language-detection) diff --git a/generator/10.gru-seq2seq-beam-word.ipynb b/generator/10.gru-seq2seq-beam-word.ipynb new file mode 100644 index 0000000..163d0b1 --- /dev/null +++ b/generator/10.gru-seq2seq-beam-word.ipynb @@ -0,0 +1,351 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import random\n", + "import time\n", + "import collections\n", + "from tqdm import tqdm\n", + "sns.set()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dataset(words, n_words, atleast=1):\n", + " count = [['PAD', 0], ['GO', 1], ['EOS', 2], ['UNK', 3]]\n", + " counter = collections.Counter(words).most_common(n_words)\n", + " counter = [i for i in counter if i[1] >= atleast]\n", + " count.extend(counter)\n", + " dictionary = dict()\n", + " for word, _ in count:\n", + " dictionary[word] = len(dictionary)\n", + " data = list()\n", + " unk_count = 0\n", + " for word in words:\n", + " index = dictionary.get(word, 0)\n", + " if index == 0:\n", + " unk_count += 1\n", + " data.append(index)\n", + " count[0][1] = unk_count\n", + " reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n", + " return data, count, dictionary, reversed_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "with open('shakespeare.txt') as fopen:\n", + " shakespeare = fopen.read().split()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "vocabulary_size = len(list(set(shakespeare)))\n", + "data, count, dictionary, rev_dictionary = build_dataset(shakespeare, vocabulary_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "GO = dictionary['GO']\n", + "PAD = dictionary['PAD']\n", + "EOS = dictionary['EOS']\n", + "UNK = dictionary['UNK']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Generator:\n", + " def __init__(self, size_layer, num_layers, embedded_size,\n", + " from_dict_size, to_dict_size, learning_rate, batch_size):\n", + " \n", + " def cells(reuse=False):\n", + " return tf.nn.rnn_cell.GRUCell(size_layer,reuse=reuse)\n", + " \n", + " self.X = tf.placeholder(tf.int32, [None, None])\n", + " self.Y = tf.placeholder(tf.int32, [None, None])\n", + " self.X_seq_len = tf.count_nonzero(self.X, 1, dtype=tf.int32)\n", + " self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype=tf.int32)\n", + " batch_size = tf.shape(self.X)[0]\n", + " \n", + " encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n", + " decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n", + " \n", + " self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " self.encoder_state = self.cells.zero_state(\n", + " dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n", + " )\n", + " \n", + " _, encoder_state = tf.nn.dynamic_rnn(\n", + " cell = self.cells, \n", + " inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n", + " sequence_length = self.X_seq_len,\n", + " initial_state = self.encoder_state,\n", + " dtype = tf.float32)\n", + " \n", + " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", + " decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", + " dense = tf.layers.Dense(to_dict_size)\n", + " decoder_cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " \n", + " training_helper = tf.contrib.seq2seq.TrainingHelper(\n", + " inputs = tf.nn.embedding_lookup(decoder_embedding, decoder_input),\n", + " sequence_length = self.Y_seq_len,\n", + " time_major = False)\n", + " training_decoder = tf.contrib.seq2seq.BasicDecoder(\n", + " cell = decoder_cells,\n", + " helper = training_helper,\n", + " initial_state = encoder_state,\n", + " output_layer = dense)\n", + " training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = training_decoder,\n", + " impute_finished = True,\n", + " maximum_iterations = tf.reduce_max(self.Y_seq_len))\n", + " self.training_logits = training_decoder_output.rnn_output\n", + " \n", + " predicting_decoder = tf.contrib.seq2seq.BeamSearchDecoder(\n", + " cell = decoder_cells,\n", + " embedding = decoder_embedding,\n", + " start_tokens = tf.tile(tf.constant([GO], dtype=tf.int32), [batch_size]),\n", + " end_token = EOS,\n", + " initial_state = tf.contrib.seq2seq.tile_batch(self.encoder_state, 15),\n", + " beam_width = 15,\n", + " output_layer = dense,\n", + " length_penalty_weight = 0.0)\n", + " predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = predicting_decoder,\n", + " impute_finished = False,\n", + " maximum_iterations = tf.reduce_max(self.X_seq_len))\n", + " \n", + " self.predicting_ids = predicting_decoder_output.predicted_ids[:,:,0]\n", + " \n", + " masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n", + " self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.training_logits,\n", + " targets = self.Y,\n", + " weights = masks)\n", + " self.optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(self.cost)\n", + " \n", + " y_t = tf.argmax(self.training_logits,axis=2)\n", + " y_t = tf.cast(y_t, tf.int32)\n", + " self.prediction = tf.boolean_mask(y_t, masks)\n", + " mask_label = tf.boolean_mask(self.Y, masks)\n", + " correct_pred = tf.equal(self.prediction, mask_label)\n", + " correct_index = tf.cast(correct_pred, tf.float32)\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = 0.001\n", + "batch_size = 32\n", + "sequence_length = 64\n", + "epoch = 3000\n", + "num_layers = 2\n", + "size_layer = 256\n", + "possible_batch_id = range(len(data) - sequence_length - 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "tf.reset_default_graph()\n", + "sess = tf.InteractiveSession()\n", + "model = Generator(size_layer, num_layers, size_layer, len(dictionary), \n", + " len(dictionary), learning_rate,batch_size)\n", + "sess.run(tf.global_variables_initializer())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def train_random_batch():\n", + " LOST, ACCURACY = [], []\n", + " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " for n in range(batch_size):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " batch_x[n] = data[index:index + sequence_length]\n", + " batch_y[n] = data[index + 1:index + sequence_length + 1] + [EOS]\n", + " initial_state, _ = sess.run([model.predict_state, model.optimizer], feed_dict = {model.X: batch_x,\n", + " model.Y: batch_y})\n", + " initial_state = initial_state.cell_state\n", + " initial_state = (initial_state[0][:,-1,:], initial_state[1][:,-1,:])\n", + " \n", + " for i in pbar:\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " for n in range(batch_size):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " batch_x[n] = data[index:index + sequence_length]\n", + " batch_y[n] = data[index + 1:index + sequence_length + 1] + [EOS]\n", + " accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n", + " model.cost, model.predict_state], \n", + " feed_dict = {model.X: batch_x, \n", + " model.Y: batch_y,\n", + " model.encoder_state: initial_state})\n", + " initial_state = initial_state.cell_state\n", + " initial_state = (initial_state[0][:,-1,:], initial_state[1][:,-1,:])\n", + " ACCURACY.append(accuracy); LOST.append(loss)\n", + " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", + " return LOST, ACCURACY" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "epoch: 100%|██████████| 3000/3000 [27:14<00:00, 2.08it/s, accuracy=0.348, cost=3.35] \n" + ] + } + ], + "source": [ + "LOST, ACCURACY = train_random_batch()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "EPOCH = np.arange(len(LOST))\n", + "plt.plot(EPOCH, LOST)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('loss')\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(EPOCH, ACCURACY)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_based_sequence(length_sentence):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " x = np.array([data[index:index + sequence_length]])\n", + " initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: x})\n", + " initial_state = initial_state.cell_state\n", + " initial_state = (initial_state[0][:,-1,:], initial_state[1][:,-1,:])\n", + " ids = ids[0].tolist()\n", + "\n", + " while len(ids) < length_sentence:\n", + " initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: [ids[-sequence_length:]],\n", + " model.encoder_state: initial_state})\n", + " ids.extend(ids_[0].tolist())\n", + " initial_state = initial_state.cell_state\n", + " initial_state = (initial_state[0][:,-1,:], initial_state[1][:,-1,:])\n", + "\n", + " return ' '.join([rev_dictionary[i] for i in ids])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS EOS\n" + ] + } + ], + "source": [ + "print(generate_based_sequence(1000))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/generator/11.gru-seq2seq-bahdanau-greedy-char.ipynb b/generator/11.gru-seq2seq-bahdanau-greedy-char.ipynb new file mode 100644 index 0000000..349ef7c --- /dev/null +++ b/generator/11.gru-seq2seq-bahdanau-greedy-char.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import random\n", + "import time\n", + "import collections\n", + "from tqdm import tqdm\n", + "sns.set()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dataset(words, n_words, atleast=1):\n", + " count = [['PAD', 0], ['GO', 1], ['EOS', 2], ['UNK', 3]]\n", + " counter = collections.Counter(words).most_common(n_words)\n", + " counter = [i for i in counter if i[1] >= atleast]\n", + " count.extend(counter)\n", + " dictionary = dict()\n", + " for word, _ in count:\n", + " dictionary[word] = len(dictionary)\n", + " data = list()\n", + " unk_count = 0\n", + " for word in words:\n", + " index = dictionary.get(word, 0)\n", + " if index == 0:\n", + " unk_count += 1\n", + " data.append(index)\n", + " count[0][1] = unk_count\n", + " reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n", + " return data, count, dictionary, reversed_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "with open('shakespeare.txt') as fopen:\n", + " shakespeare = fopen.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "vocabulary_size = len(list(set(shakespeare)))\n", + "data, count, dictionary, rev_dictionary = build_dataset(shakespeare, vocabulary_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "GO = dictionary['GO']\n", + "PAD = dictionary['PAD']\n", + "EOS = dictionary['EOS']\n", + "UNK = dictionary['UNK']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Generator:\n", + " def __init__(self, size_layer, num_layers, embedded_size,\n", + " from_dict_size, to_dict_size, learning_rate, batch_size):\n", + " \n", + " def cells(reuse=False):\n", + " return tf.nn.rnn_cell.GRUCell(size_layer,reuse=reuse)\n", + " \n", + " self.X = tf.placeholder(tf.int32, [None, None])\n", + " self.Y = tf.placeholder(tf.int32, [None, None])\n", + " self.X_seq_len = tf.count_nonzero(self.X, 1, dtype=tf.int32)\n", + " self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype=tf.int32)\n", + " batch_size = tf.shape(self.X)[0]\n", + " \n", + " encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n", + " decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n", + " self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " self.encoder_state = self.cells.zero_state(\n", + " dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n", + " )\n", + " \n", + " encoder_out, encoder_state = tf.nn.dynamic_rnn(\n", + " cell = self.cells, \n", + " inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n", + " sequence_length = self.X_seq_len,\n", + " initial_state = self.encoder_state,\n", + " dtype = tf.float32)\n", + " \n", + " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", + " decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", + " dense = tf.layers.Dense(to_dict_size)\n", + " attention_mechanism = tf.contrib.seq2seq.LuongAttention(num_units = size_layer, \n", + " memory = encoder_out,\n", + " memory_sequence_length = self.X_seq_len)\n", + " \n", + " decoder_cells = tf.contrib.seq2seq.AttentionWrapper(\n", + " cell = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)]), \n", + " attention_mechanism = attention_mechanism,\n", + " attention_layer_size = size_layer)\n", + " \n", + " training_helper = tf.contrib.seq2seq.TrainingHelper(\n", + " inputs = tf.nn.embedding_lookup(decoder_embedding, decoder_input),\n", + " sequence_length = self.Y_seq_len,\n", + " time_major = False)\n", + " training_decoder = tf.contrib.seq2seq.BasicDecoder(\n", + " cell = decoder_cells,\n", + " helper = training_helper,\n", + " initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n", + " output_layer = dense)\n", + " training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = training_decoder,\n", + " impute_finished = True,\n", + " maximum_iterations = tf.reduce_max(self.Y_seq_len))\n", + " self.training_logits = training_decoder_output.rnn_output\n", + " \n", + " predicting_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(\n", + " embedding = decoder_embedding,\n", + " start_tokens = tf.tile(tf.constant([GO], dtype=tf.int32), [batch_size]),\n", + " end_token = EOS)\n", + " predicting_decoder = tf.contrib.seq2seq.BasicDecoder(\n", + " cell = decoder_cells,\n", + " helper = predicting_helper,\n", + " initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n", + " output_layer = dense)\n", + " predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = predicting_decoder,\n", + " impute_finished = True,\n", + " maximum_iterations = tf.reduce_max(self.X_seq_len))\n", + " self.predicting_ids = predicting_decoder_output.sample_id\n", + " print(self.training_state, self.predict_state)\n", + " \n", + " masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n", + " self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.training_logits,\n", + " targets = self.Y,\n", + " weights = masks)\n", + " self.optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(self.cost)\n", + " \n", + " y_t = tf.argmax(self.training_logits,axis=2)\n", + " y_t = tf.cast(y_t, tf.int32)\n", + " self.prediction = tf.boolean_mask(y_t, masks)\n", + " mask_label = tf.boolean_mask(self.Y, masks)\n", + " correct_pred = tf.equal(self.prediction, mask_label)\n", + " correct_index = tf.cast(correct_pred, tf.float32)\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = 0.001\n", + "batch_size = 32\n", + "sequence_length = 64\n", + "epoch = 3000\n", + "num_layers = 2\n", + "size_layer = 256\n", + "possible_batch_id = range(len(data) - sequence_length - 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AttentionWrapperState(cell_state=(, ), attention=, time=, alignments=, alignment_history=(), attention_state=) AttentionWrapperState(cell_state=(, ), attention=, time=, alignments=, alignment_history=(), attention_state=)\n" + ] + } + ], + "source": [ + "tf.reset_default_graph()\n", + "sess = tf.InteractiveSession()\n", + "model = Generator(size_layer, num_layers, size_layer, len(dictionary), \n", + " len(dictionary), learning_rate,batch_size)\n", + "sess.run(tf.global_variables_initializer())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def train_random_batch():\n", + " LOST, ACCURACY = [], []\n", + " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " for n in range(sequence_length):\n", + " id1 = [data[k + n] for k in batch_id]\n", + " id2 = [data[k + n + 1] for k in batch_id]\n", + " batch_x[:,n] = id1\n", + " batch_y[:,n] = id2\n", + " batch_y[:,-1] = [EOS] * batch_size\n", + " batch_x = batch_x.astype('int32')\n", + " batch_y = batch_y.astype('int32')\n", + " initial_state, _ = sess.run([model.predict_state, model.optimizer], feed_dict = {model.X: batch_x,\n", + " model.Y: batch_y})\n", + " initial_state = initial_state.cell_state\n", + " \n", + " for i in pbar:\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " for n in range(sequence_length):\n", + " id1 = [data[k + n] for k in batch_id]\n", + " id2 = [data[k + n + 1] for k in batch_id]\n", + " batch_x[:,n] = id1\n", + " batch_y[:,n] = id2\n", + " batch_y[:,-1] = [EOS] * batch_size\n", + " accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n", + " model.cost, model.predict_state], \n", + " feed_dict = {model.X: batch_x, \n", + " model.Y: batch_y,\n", + " model.encoder_state: initial_state})\n", + " initial_state = initial_state.cell_state\n", + " ACCURACY.append(accuracy); LOST.append(loss)\n", + " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", + " return LOST, ACCURACY" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "epoch: 100%|██████████| 3000/3000 [21:14<00:00, 2.37it/s, accuracy=0.986, cost=0.0703]\n" + ] + } + ], + "source": [ + "LOST, ACCURACY = train_random_batch()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "EPOCH = np.arange(len(LOST))\n", + "plt.plot(EPOCH, LOST)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('loss')\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(EPOCH, ACCURACY)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_based_sequence(length_sentence):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " x = np.array([data[index:index + sequence_length]])\n", + " initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: x})\n", + " initial_state = initial_state.cell_state\n", + " ids = ids[0].tolist()\n", + " \n", + " while len(ids) < length_sentence:\n", + " initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: [ids[-sequence_length:]],\n", + " model.encoder_state: initial_state})\n", + " initial_state = initial_state.cell_state\n", + " ids.extend(ids_[0].tolist())\n", + "\n", + " return ''.join([rev_dictionary[i] for i in ids])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ut want their remedies.\n", + "Cousin, I am tooung aftEOSt want their remedies.\n", + "Cousin, I am tooung aft\n", + "S am tooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Suam tooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sunm tooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund tooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund tooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund sooung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seoung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOSung aft\n", + "t want their remedies.\n", + "Cousin, I am tooung aft\n", + "Sund seEOS\n" + ] + } + ], + "source": [ + "print(generate_based_sequence(1000))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/generator/12.gru-seq2seq-bahdanau-greedy-word.ipynb b/generator/12.gru-seq2seq-bahdanau-greedy-word.ipynb new file mode 100644 index 0000000..e67a5e2 --- /dev/null +++ b/generator/12.gru-seq2seq-bahdanau-greedy-word.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import random\n", + "import time\n", + "import collections\n", + "from tqdm import tqdm\n", + "sns.set()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dataset(words, n_words, atleast=1):\n", + " count = [['PAD', 0], ['GO', 1], ['EOS', 2], ['UNK', 3]]\n", + " counter = collections.Counter(words).most_common(n_words)\n", + " counter = [i for i in counter if i[1] >= atleast]\n", + " count.extend(counter)\n", + " dictionary = dict()\n", + " for word, _ in count:\n", + " dictionary[word] = len(dictionary)\n", + " data = list()\n", + " unk_count = 0\n", + " for word in words:\n", + " index = dictionary.get(word, 0)\n", + " if index == 0:\n", + " unk_count += 1\n", + " data.append(index)\n", + " count[0][1] = unk_count\n", + " reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n", + " return data, count, dictionary, reversed_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "with open('shakespeare.txt') as fopen:\n", + " shakespeare = fopen.read().split()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "vocabulary_size = len(list(set(shakespeare)))\n", + "data, count, dictionary, rev_dictionary = build_dataset(shakespeare, vocabulary_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "GO = dictionary['GO']\n", + "PAD = dictionary['PAD']\n", + "EOS = dictionary['EOS']\n", + "UNK = dictionary['UNK']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Generator:\n", + " def __init__(self, size_layer, num_layers, embedded_size,\n", + " from_dict_size, to_dict_size, learning_rate, batch_size):\n", + " \n", + " def cells(reuse=False):\n", + " return tf.nn.rnn_cell.GRUCell(size_layer,reuse=reuse)\n", + " \n", + " self.X = tf.placeholder(tf.int32, [None, None])\n", + " self.Y = tf.placeholder(tf.int32, [None, None])\n", + " self.X_seq_len = tf.count_nonzero(self.X, 1, dtype=tf.int32)\n", + " self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype=tf.int32)\n", + " batch_size = tf.shape(self.X)[0]\n", + " \n", + " encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n", + " decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n", + " self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " self.encoder_state = self.cells.zero_state(\n", + " dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n", + " )\n", + " \n", + " encoder_out, encoder_state = tf.nn.dynamic_rnn(\n", + " cell = self.cells, \n", + " inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n", + " sequence_length = self.X_seq_len,\n", + " initial_state = self.encoder_state,\n", + " dtype = tf.float32)\n", + " \n", + " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", + " decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", + " dense = tf.layers.Dense(to_dict_size)\n", + " attention_mechanism = tf.contrib.seq2seq.LuongAttention(num_units = size_layer, \n", + " memory = encoder_out,\n", + " memory_sequence_length = self.X_seq_len)\n", + " \n", + " decoder_cells = tf.contrib.seq2seq.AttentionWrapper(\n", + " cell = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)]), \n", + " attention_mechanism = attention_mechanism,\n", + " attention_layer_size = size_layer)\n", + " \n", + " training_helper = tf.contrib.seq2seq.TrainingHelper(\n", + " inputs = tf.nn.embedding_lookup(decoder_embedding, decoder_input),\n", + " sequence_length = self.Y_seq_len,\n", + " time_major = False)\n", + " training_decoder = tf.contrib.seq2seq.BasicDecoder(\n", + " cell = decoder_cells,\n", + " helper = training_helper,\n", + " initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n", + " output_layer = dense)\n", + " training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = training_decoder,\n", + " impute_finished = True,\n", + " maximum_iterations = tf.reduce_max(self.Y_seq_len))\n", + " self.training_logits = training_decoder_output.rnn_output\n", + " \n", + " predicting_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(\n", + " embedding = decoder_embedding,\n", + " start_tokens = tf.tile(tf.constant([GO], dtype=tf.int32), [batch_size]),\n", + " end_token = EOS)\n", + " predicting_decoder = tf.contrib.seq2seq.BasicDecoder(\n", + " cell = decoder_cells,\n", + " helper = predicting_helper,\n", + " initial_state = decoder_cells.zero_state(batch_size, tf.float32).clone(cell_state=encoder_state),\n", + " output_layer = dense)\n", + " predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " decoder = predicting_decoder,\n", + " impute_finished = True,\n", + " maximum_iterations = tf.reduce_max(self.X_seq_len))\n", + " self.predicting_ids = predicting_decoder_output.sample_id\n", + " print(self.training_state, self.predict_state)\n", + " \n", + " masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n", + " self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.training_logits,\n", + " targets = self.Y,\n", + " weights = masks)\n", + " self.optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(self.cost)\n", + " \n", + " y_t = tf.argmax(self.training_logits,axis=2)\n", + " y_t = tf.cast(y_t, tf.int32)\n", + " self.prediction = tf.boolean_mask(y_t, masks)\n", + " mask_label = tf.boolean_mask(self.Y, masks)\n", + " correct_pred = tf.equal(self.prediction, mask_label)\n", + " correct_index = tf.cast(correct_pred, tf.float32)\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = 0.001\n", + "batch_size = 32\n", + "sequence_length = 64\n", + "epoch = 3000\n", + "num_layers = 2\n", + "size_layer = 256\n", + "possible_batch_id = range(len(data) - sequence_length - 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AttentionWrapperState(cell_state=(, ), attention=, time=, alignments=, alignment_history=(), attention_state=) AttentionWrapperState(cell_state=(, ), attention=, time=, alignments=, alignment_history=(), attention_state=)\n" + ] + } + ], + "source": [ + "tf.reset_default_graph()\n", + "sess = tf.InteractiveSession()\n", + "model = Generator(size_layer, num_layers, size_layer, len(dictionary), \n", + " len(dictionary), learning_rate,batch_size)\n", + "sess.run(tf.global_variables_initializer())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def train_random_batch():\n", + " LOST, ACCURACY = [], []\n", + " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " for n in range(sequence_length):\n", + " id1 = [data[k + n] for k in batch_id]\n", + " id2 = [data[k + n + 1] for k in batch_id]\n", + " batch_x[:,n] = id1\n", + " batch_y[:,n] = id2\n", + " batch_y[:,-1] = [EOS] * batch_size\n", + " initial_state, _ = sess.run([model.predict_state, model.optimizer], feed_dict = {model.X: batch_x,\n", + " model.Y: batch_y})\n", + " initial_state = initial_state.cell_state\n", + " \n", + " for i in pbar:\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " batch_y = np.zeros((batch_size, sequence_length + 1))\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " for n in range(sequence_length):\n", + " id1 = [data[k + n] for k in batch_id]\n", + " id2 = [data[k + n + 1] for k in batch_id]\n", + " batch_x[:,n] = id1\n", + " batch_y[:,n] = id2\n", + " batch_y[:,-1] = [EOS] * batch_size\n", + " accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n", + " model.cost, model.predict_state], \n", + " feed_dict = {model.X: batch_x, \n", + " model.Y: batch_y,\n", + " model.encoder_state: initial_state})\n", + " initial_state = initial_state.cell_state\n", + " ACCURACY.append(accuracy); LOST.append(loss)\n", + " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", + " return LOST, ACCURACY" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "epoch: 100%|██████████| 3000/3000 [1:41:50<00:00, 1.03s/it, accuracy=0.0591, cost=6.7] \n" + ] + } + ], + "source": [ + "LOST, ACCURACY = train_random_batch()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (15, 5))\n", + "plt.subplot(1, 2, 1)\n", + "EPOCH = np.arange(len(LOST))\n", + "plt.plot(EPOCH, LOST)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('loss')\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(EPOCH, ACCURACY)\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_based_sequence(length_sentence):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " x = np.array([data[index:index + sequence_length]])\n", + " initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: x})\n", + " initial_state = initial_state.cell_state\n", + " ids = ids[0].tolist()\n", + " \n", + " while len(ids) < length_sentence:\n", + " initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: [ids[-sequence_length:]],\n", + " model.encoder_state: initial_state})\n", + " initial_state = initial_state.cell_state\n", + " ids.extend(ids_[0].tolist())\n", + "\n", + " return ''.join([rev_dictionary[i] for i in ids])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "withaoldownaoldownMERCUTIO:andaoldownownownownownownownownownownownownownownownownownownownownownownMERCUTIO:andaEOSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doaalook,--doaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaalook,--doalook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--doalook,--dolook,--dolook,--doalook,--dolook,--doalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--dolook,--doaalook,--doaalook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--dolook,--doVolsce:youmalignEOSyouyouyouyouyouyouyouyouyouyouyouyouEOSyouyouyouguess?guess?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?Jacks?EOSIyouyouIhavenotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotEOSshallnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotnotEOSANNE:notnotnotnotnotnotnotnotnotnotnotEOSANNE:notnotnotnotnotnotnotnotnotnotEOSthousharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedsharp-pointedEOScontempt.eyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballeyeballofthetheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseaoftheseawiththethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethetheEOSwiththethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethecymbalsthethelawyersthethelawyersthethethelawyersthethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethethetheServingman:Rome?MasterServingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Master,MasterServingman:MasterServingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:Servingman:\n" + ] + } + ], + "source": [ + "print(generate_based_sequence(1000))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/generator/6.gru-seq2seq-greedy-char.ipynb b/generator/6.gru-seq2seq-greedy-char.ipynb index 3a60ad1..8e8daed 100644 --- a/generator/6.gru-seq2seq-greedy-char.ipynb +++ b/generator/6.gru-seq2seq-greedy-char.ipynb @@ -96,11 +96,16 @@ " \n", " encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n", " decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n", + " self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " self.encoder_state = self.cells.zero_state(\n", + " dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n", + " )\n", " \n", " _, encoder_state = tf.nn.dynamic_rnn(\n", - " cell = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)]), \n", + " cell = self.cells, \n", " inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n", " sequence_length = self.X_seq_len,\n", + " initial_state = self.encoder_state,\n", " dtype = tf.float32)\n", " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", " decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", @@ -116,7 +121,7 @@ " helper = training_helper,\n", " initial_state = encoder_state,\n", " output_layer = dense)\n", - " training_decoder_output, _, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", " decoder = training_decoder,\n", " impute_finished = True,\n", " maximum_iterations = tf.reduce_max(self.Y_seq_len))\n", @@ -131,11 +136,12 @@ " helper = predicting_helper,\n", " initial_state = encoder_state,\n", " output_layer = dense)\n", - " predicting_decoder_output, _, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", " decoder = predicting_decoder,\n", " impute_finished = True,\n", " maximum_iterations = tf.reduce_max(self.X_seq_len))\n", " self.predicting_ids = predicting_decoder_output.sample_id\n", + " print(self.training_state, self.predict_state)\n", " \n", " masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n", " self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.training_logits,\n", @@ -171,7 +177,15 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(, ) (, )\n" + ] + } + ], "source": [ "tf.reset_default_graph()\n", "sess = tf.InteractiveSession()\n", @@ -189,6 +203,11 @@ "def train_random_batch():\n", " LOST, ACCURACY = [], []\n", " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " for n in range(batch_size):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " batch_x[n] = data[index:index + sequence_length]\n", + " initial_state = sess.run(model.predict_state, feed_dict = {model.X: batch_x})\n", " for i in pbar:\n", " batch_x = np.zeros((batch_size, sequence_length))\n", " batch_y = np.zeros((batch_size, sequence_length + 1))\n", @@ -196,9 +215,11 @@ " index = np.random.randint(0, len(data) - sequence_length - 1)\n", " batch_x[n] = data[index:index + sequence_length]\n", " batch_y[n] = data[index + 1:index + sequence_length + 1] + [EOS]\n", - " accuracy, _, loss = sess.run([model.accuracy, model.optimizer, model.cost], \n", + " accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n", + " model.cost, model.predict_state], \n", " feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", + " model.Y: batch_y,\n", + " model.encoder_state: initial_state})\n", " ACCURACY.append(accuracy); LOST.append(loss)\n", " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", " return LOST, ACCURACY" @@ -213,7 +234,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "epoch: 100%|██████████| 3000/3000 [05:43<00:00, 8.90it/s, accuracy=0.758, cost=0.776]\n" + "epoch: 100%|██████████| 3000/3000 [07:16<00:00, 7.02it/s, accuracy=0.744, cost=0.806]\n" ] } ], @@ -228,7 +249,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -255,100 +276,67 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 4, 6, 7, 12, 24, 17, 5, 10, 29, 14, 14, 51, 44, 41, 45, 35,\n", - " 39, 39, 4, 46, 8, 11, 23, 13, 17, 10, 4, 22, 7, 15, 15, 7,\n", - " 21, 5, 11, 28, 14, 43, 5, 4, 9, 5, 8, 11, 4, 6, 9, 5,\n", - " 4, 18, 8, 12, 4, 7, 22, 4, 27, 11, 7, 31, 5, 20, 4, 8]],\n", - " dtype=int32)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def generate_based_sequence(length_sentence):\n", " index = np.random.randint(0, len(data) - sequence_length - 1)\n", - " ids = sess.run(model.predicting_ids, feed_dict = {model.X:[data[index:index + sequence_length]]})[0]\n", - " ids = ids.tolist()\n", + " x = np.array([data[index:index + sequence_length]])\n", + " initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: x})\n", + " ids = ids[0].tolist()\n", "\n", " while len(ids) < length_sentence:\n", - " new_ids = sess.run(model.predicting_ids, feed_dict = {model.X:[ids[-sequence_length:]]})[0]\n", - " new_ids = new_ids.tolist()\n", - " ids += new_ids\n", + " initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: [ids[-sequence_length:]],\n", + " model.encoder_state: initial_state})\n", + " ids.extend(ids_[0].tolist())\n", "\n", " return ''.join([rev_dictionary[i] for i in ids])" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ar this worfort we have a king:\n", - "Better in the cannot swear in cor this worforth we again. I hear in them\n", - "Because it on the cause this worfort way fought a king.\n", - "Where in the can on the kings.\n", - "this worfort way for what in he\n", - "With cereman to know in the chanhis worforw worth a woman with\n", - "her citizen the mocked in hang.\n", - "\n", - "is worforw worth water woman\n", - "With her comminted the king condents worforw worth water\n", - "would make him the crown in the king.\n", - "\n", - "BUC worforwow worth\n", - "wate worth me hither can to give king.\n", - "\n", - "BUCKINGworforwoworw\n", - "worth water worth the city can give king.\n", - "\n", - "BUCKINGHorfowrow\n", - "wortworth war worth the city can give king.\n", - "\n", - "BUCKINGHAMrfowrow\n", - "worthward worthy the cright and king.\n", + " te houge you not.\n", "\n", - "KING HENRY BOLINGfoworw\n", - "wrown what to her thrick with can delive.\n", + "DUKE OF YORK:\n", + "See, good men, the means of mythe goue you not.\n", "\n", - "KING HENRY BOEOSowworw\n", - "what wront that whom the prince.\n", - "His gave know me.\n", + "DUKE OF YORK:\n", + "Speak, good men, the most fair he goue you not.\n", "\n", - "HENRYwwwowrw\n", - "what wront that where him.\n", + "DUKE OF YORK:\n", + "Speak, good mean, to my bread the goue you not.\n", "\n", "DUKE VINCENTIO:\n", - "He knight hawwwwharw\n", - "what wront that where him.\n", + "Speak, good mean, for the man b goue you knon\n", + "To please. Go, give me of good, and the mouble\n", + "Thgoue you know me.\n", "\n", - "HENRY BOLINGBROKE:\n", - "He king wwwharwhat\n", - "wrong wather then which.\n", + "GLOUCESTER:\n", + "I plove, I plant me the poor fathou undey thou go.\n", "\n", - "HENRY BOLINGBROKE:\n", - "He kingEOS\n" + "GLOUCESTER:\n", + "I plant, I plead me to her face ou undey though of\n", + "peague, I plant. God plant me be the mouth, an undey though off\n", + "peage, good and place of pale the people,\n", + "Thatyned youth good people,\n", + "Baganion pale bold, and the people may wned yout good peecedo,\n", + "My power, and place and place the people,ed youg to pedge,\n", + "people, power palace, and place and peace the d you got peed,\n", + "people, poor place, and pale and place and here you pot peed,\n", + "people, poor place, and pale and partle peace,\n", + "Thyou pot peep,\n", + "poor, people, poor place, and appear and peace theou ppot peop,\n", + "peror, poolight, poor peace, and appear and the pe\n" ] } ], diff --git a/generator/7.gru-seq2seq-greedy-word.ipynb b/generator/7.gru-seq2seq-greedy-word.ipynb index 29b806e..eedc681 100644 --- a/generator/7.gru-seq2seq-greedy-word.ipynb +++ b/generator/7.gru-seq2seq-greedy-word.ipynb @@ -97,10 +97,16 @@ " encoder_embedding = tf.Variable(tf.random_uniform([from_dict_size, embedded_size], -1, 1))\n", " decoder_embedding = tf.Variable(tf.random_uniform([to_dict_size, embedded_size], -1, 1))\n", " \n", + " self.cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n", + " self.encoder_state = self.cells.zero_state(\n", + " dtype = tf.float32, batch_size = tf.shape(self.X)[0]\n", + " )\n", + " \n", " _, encoder_state = tf.nn.dynamic_rnn(\n", - " cell = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)]), \n", + " cell = self.cells, \n", " inputs = tf.nn.embedding_lookup(encoder_embedding, self.X),\n", " sequence_length = self.X_seq_len,\n", + " initial_state = self.encoder_state,\n", " dtype = tf.float32)\n", " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", " decoder_input = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", @@ -116,7 +122,7 @@ " helper = training_helper,\n", " initial_state = encoder_state,\n", " output_layer = dense)\n", - " training_decoder_output, _, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " training_decoder_output, self.training_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", " decoder = training_decoder,\n", " impute_finished = True,\n", " maximum_iterations = tf.reduce_max(self.Y_seq_len))\n", @@ -131,7 +137,7 @@ " helper = predicting_helper,\n", " initial_state = encoder_state,\n", " output_layer = dense)\n", - " predicting_decoder_output, _, _ = tf.contrib.seq2seq.dynamic_decode(\n", + " predicting_decoder_output, self.predict_state, _ = tf.contrib.seq2seq.dynamic_decode(\n", " decoder = predicting_decoder,\n", " impute_finished = True,\n", " maximum_iterations = tf.reduce_max(self.X_seq_len))\n", @@ -189,6 +195,11 @@ "def train_random_batch():\n", " LOST, ACCURACY = [], []\n", " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_x = np.zeros((batch_size, sequence_length))\n", + " for n in range(batch_size):\n", + " index = np.random.randint(0, len(data) - sequence_length - 1)\n", + " batch_x[n] = data[index:index + sequence_length]\n", + " initial_state = sess.run(model.predict_state, feed_dict = {model.X: batch_x})\n", " for i in pbar:\n", " batch_x = np.zeros((batch_size, sequence_length))\n", " batch_y = np.zeros((batch_size, sequence_length + 1))\n", @@ -196,9 +207,11 @@ " index = np.random.randint(0, len(data) - sequence_length - 1)\n", " batch_x[n] = data[index:index + sequence_length]\n", " batch_y[n] = data[index + 1:index + sequence_length + 1] + [EOS]\n", - " accuracy, _, loss = sess.run([model.accuracy, model.optimizer, model.cost], \n", + " accuracy, _, loss, initial_state = sess.run([model.accuracy, model.optimizer, \n", + " model.cost, model.predict_state], \n", " feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", + " model.Y: batch_y,\n", + " model.encoder_state: initial_state})\n", " ACCURACY.append(accuracy); LOST.append(loss)\n", " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", " return LOST, ACCURACY" @@ -213,7 +226,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "epoch: 100%|██████████| 3000/3000 [18:25<00:00, 2.72it/s, accuracy=0.401, cost=3.11] \n" + "epoch: 100%|██████████| 3000/3000 [31:13<00:00, 1.62it/s, accuracy=0.434, cost=2.9] \n" ] } ], @@ -228,7 +241,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4UAAAFICAYAAADnOVvjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl8VNX9//HXzGRfCSFA2NcckEUEVFBwwaWK1drFVq1LXap20W7Wn22/tXbRYm1rW6tVUVqr1Spt3a1bUVEEAWVfDjthC4SwZIHs8/tjJpOZyWRPZiYz7+fjwSP3nnvunc9JeGTymbM53G43IiIiIiIiEp+ckQ5AREREREREIkdJoYiIiIiISBxTUigiIiIiIhLHlBSKiIiIiIjEMSWFIiIiIiIicUxJoYiIiIiISBxTUigiIiIiIhLHlBSKiIiIiIjEMSWFIiIiIiIicUxJoYiIiIiISBxTUigiIiIiIhLHEiIdQBdKBk4G9gF1EY5FRES6lwvIB5YBVRGOpSfQe6SISHzo0PtjLCWFJwMfRDoIEREJq5nAh5EOogfQe6SISHxp1/tjLCWF+wAOH66gvt7d4Yfk5mZQUlLeZUFFK7UzdsRDG0HtjCVd0Uan00FOTjp4f/dLq/Qe2Q7x0M54aCOonbEkHtoInW9nR98fYykprAOor3d36g2v4RnxQO2MHfHQRlA7Y0kXtlFDIdtG75HtFA/tjIc2gtoZS+KhjdBl7WzX+6MWmhEREREREYljSgpFRERERETimJJCERERERGROKakUEREREREJI4pKRQREREREYljSgpFRERERETimJJCERERERGROBZL+xSKiIj0OMaYAuBJIBcoAa6x1m4OqtMX+CswGEgE3gVus9bWhjlcERGJQeop9FO4v4yf/GURNbXaC1lERMLmEeAha20B8BDwaIg6PwY2WGsnAhOBKcAXwheiiIi01aHSSr77pw/Yf+gYAPtKKvjH25uod4felL6mtr6rNqzvMCWFfnbuL2P1loMcraiOdCgiIhIHvD2Ak4FnvUXPApONMXlBVd1ApjHGCSQDScCesAUqIiIB/vLiWpZvPBDy2uJ1RZQeq2Hhqr0A/PFfq/nfJ7spPnw8ZP2bf/seD72wpttibQslhX6cDgcAzSTxIiIiXW0wsMdaWwfg/brXW+7vl0ABsA8oAt601i4KZ6AiIj1V+fGaLnvW0g37uX7OApZtPMDDL64F4MePLeH7f/6waWVPauHrBfSmGiGt2HyQJeuKcEcoEdGcQj8NP6hI/TBERESacRmwGjgHyAT+a4z5krX2X+15SG5uRqcDycvL7PQzeoJ4aGc8tBHUzljSkTZ+uGoP9/19Ob+9bSZmaO9W67vdbpat38+UMX1xuZr2ny1/aV3AeUWtmyLvMNGG+NLSkgFIT0smLy8Tp/c5W/eXc+ejS7j0zJHccMn4Js9+7JX19O2Twanj89vXyC6gpNCPA/UUiohIWO0CBhpjXNbaOmOMCxjgLfd3K3C9tbYeOGqMeQk4G2hXUlhSUt6peSt5eZkUF5d1+P6eIh7aGQ9tBLUzlnS0jUtWe4ZwrrIH6J2W2Gr9tdtK+P3zq7j4tGF8/owRrN1ewnsr9jLthH6MGJDF8crAXsdbf/uu7/iHf3yfGz97AguWFQKwbF0RM8b344A3aZzr7Vl88f2tXDJ9KIAvoWxQWlHdqZ+l0+no0AeASgr9NPQUNjcJVEREpCtZaw8YY1YCVwBPe7+usNYWB1XdDlwALDXGJAHnAv8Ja7AiInGgzDvU9MARz/y/B55bhRv4dFMx2RlJDMhNb/bejYVHuP3hj3znO/eX8fay4M/4Gj31luXdTwOnh9dFaMEZzSn042hpoK+IiEj3uAW41RizCU+P4C0AxpjXjTFTvXW+C8w0xqwBVgKbgLmRCFZEpCd44PlVLFqzzzcCMPiv/J1FZazacjCgrKKyhrmvrAfg4/X7+dO/VuOfoh0tr2bDzsPtiuO1xTtDlu8rqWiSEAI897Zt1/O7inoK/TT2FEY2DhERiR/W2o3AqSHKZ/sdbwXOC2dcIiKR4na7eenD7Zxx4gB6Z6V06BlrtpWwZlsJw/OzPAVBWeHP/7YMgHl3zvKVvR6UwK0MShq70k/mfhyy/ODRym57zZaop9BP4+qjygpFRERERCJhb8kxXl60o13bNNTXu/nPwm1s31caUN5w3pATut1unnlnk+/69XMWsGHHIZ55ZxP//biw07H3VOop9NO4+mhk4xARERER6UkOlVaSlZ5EQogVO91uN25gzdYS/viv1Tzw7dPJSk9qMnXrwJHjPPSfNVz9GQPAjqIy9pVUkJ+bjtvtZs22EsYP793kvqrqOv7079Vs2HmYVz/aQW6I3sV12w/x5Buhh2be/8+VHWx17FBS6MehnkIRERERkXaprK7l9oc/YsbEfM6bOpifzVvK9758IsP6Z5KZlsT9z65gY+ERJozIBeD1JYW8vXwXd31tKm439MpIprK6llcW7WDXgXJWbPasteV2e4ZZzrtzFg8+v5K3lxZy42fHctr4fN5cWshzC7Yw1eThhoC5fiWlTYdgLm+yfld0Ou+UIRF5XSWFftRTKCIiIiLSPlU19QCs3nKQ1CRPevHA86vISE3kD7fNYGPhEcAzzw9g1VbPXL3Fa/fz9vKmq3P+d0ngMM5Fa/bx9lJPWdkxz+qgzy3YAvScZK+tQvW0hoPmFPpp6CnUlhQiIiIiEo2OVdbwi78ta7K/XWcs3bCfT7oguXLT2MkCUH68hvnvbmlSr67O87f28eraNj3X7jriO45U0tTdstOTgMjlIbH5Xe0gp3oKRURERCSKrdxykB1FZby8aHuXPfORl9a1eVEXt9tNuXcvv2OVtdzyu/fYsPMQ0NiL52/hqr1NyhqGd364el+bXtO/3tGKKq6fs6BN9/UkLpcnEamtq4/I6ysp9KM5hSIiIiISzXyLrLTxz1VbeJiyY9Vtfn5pRTW3P7yIPcXlfLh6n28Td4DF64p4bsEWbvvjB+wrqaBwfxnVNfU89vJ6X53jVYG9f8er6tr82m3R3n0Cu0vvrOROPyM9pXEmn8O7PmpDL2q4hX1OoTHmZ8DdwARr7dqga2nAX4EpQC1wu7X21XDFpjmFIiIiIhLNGkZntnWY4X3PrGBgn3RmTxvK3FfX89tvnubb+6+2rp6b7n8voP7KLQc5VFrFGx8XsmhtEQAXnjqEgsG9fBu7A7y5tJCFq5r29FVWd20SGGzrntLWK4XBlIK+XHHuaF+v5blTB/HO8t0Bde75+qlN9iMc2i+TL541gl7pyfTrnco/3t7M9HH9eOK1DQDURWjD9LD2FBpjJgPTgJ3NVLkdKLXWjgIuBh43xmSEKz7NKRQRERGRaBa8HYO//YeP8fir631DEBtGv+05WMHcVz0JXcPCLofLqpoM7dy8u3HuXkNCCPDfjwv5479WB9QNlRACLNt4oK1NiXoD+qTzyxtO4ezJA+nfOw2A808eDMDpE/oH1L3y3ALfVhoAV5wzmvzc9CbP/M5lExk/PJdBfTNITHDxtQvHYIbk4PLOY5tx4oDuak6LwpYUGmOSgYeAb7RQ7SvAowDW2s3AcuDC7o/Oo+GboeGjIiIiIhKNGnLCUB1Kj728no/WFrGjqAwIPfqtoez2hxfx9FubAq79+ulP2bL7aFeG26N9fuZwBuZlcPX5hrFDcwDok53CvDtnMaRfJgC/uvFU7r1pGtD4sznjxAGc500ef3jFSZjBvQC49gJDr4zQw05v+9JEPnPKYKZPyO/OJjUrnMNHfwE8ba3dYYxprs4QAnsRC4HB7XmR3NyOdywWHa0CIDs7jby8zA4/p6eIhzZCfLQzHtoIamcsiYc2ioh0xJ7icn76xFJ+deOpDOjTtKepQW1t0wVJqmo8QzcTXA4WrtrLaeP7N6kDnnmGzfWBfLimbYu/RLsh/TIo3F/uO89ITeS8kwfz1tJCKio98x5vuuSEgPmQADddfAL/fn8bJaWVnDQ6z1fe0JOXlOgKqO//M2row/XvYBo7NIdh/TN5c2khMyY2n/Dl56bzlVmjW+wJ7k5hSQqNMdOBqcCd3f1aJSXl1HdwLO7Ro56lfQ8frqC4uPOTR6NZXl4mxcVlkQ6j28VDO+OhjaB2xpKuaKPT6ejUh4AiIpGwcedhqmvrmDiyT7N1lqzfD8An9gAD+gzneFUtZceq6ZvjGb7o9CYNK7ccbHJvlXeLh/+8v4212w9RF2IlywOHj3PfMys63ZZod/d1pwSsUvqn78wE4OLThvGbZz4lMy2JaSf0JzcrhV8//amv3rRx/TFDcti65yhOZ2OC9rmZw3E6HUwfFzrRBhg3rDcAMycGDgFNTU7g0pkjuqRd3SVcw0fPBMYC240xO4BBwJvGmPOD6hUCQ/3OhwBNd7TsJr7VR8P1giIiIiLS47ndburq63n2nc0cLqtqtt5vnl3BH+Z75uYdq6zxbe0Q+CzP18Pl1dTU1vOtBxZy56NLAPjLi2t5+MW1fnXdvrUwyo/XUFLqee212z1bRDwVNDwUQieT0WjCiNxOP+Oys0YCMOfmaQHld1w5mW9cOh6A0YN6cdLowCQ9JzOZqWP6BpSlpyRy+TmjSUxoPn3q0yuVeXfOYtSg7E7HHm5h6Sm01s4B5jScexPDzwavPgrMB24GlhtjRgMnA1eEI0bQ6qMiIiIi0jaHSitxuyE3O4Vn3t7M/z71rDy5r6SC739lUqv3f/sPHwAw785ZAeUNSd57K/ZwrLIxaayprWuyiMsN973bqTZEq+yMJK69wHD7wx916jkXThvKhdOGtlovy7txfDwL+5YUwYwxK4HZ1tq9wP3A34wxW4A64CZrbdjGUWmfQhERERFpi4aEZd6ds3wJITT20h2rrGXb3qOMb6XH62hFNQ4aE5OGeYEASzc0JoE1tbHz92lerxTGj8hlakEe9/9zZZPrDjy9dcEumj6U1xY33cRgSL8Mrr1gDIkJTmzhEQb37dj0gms+0+y6JzEvIkmhtXaY3/Ekv+MK4LJIxAQtr+YkIiIiIvGruqaORWv2MWJANjlt2Lj8239Y6DueYvLI8Vt18vl3t/iOv/fgh4Dn79AZE/L5YHXohV78n9dTjBqUHXI10/tuOa1JWUqSi+9/ZRL3PvUJJ4/ph8Ph4NIZw3nxw+2+Ol84Y0TIpPDu607xHQ/K03zzjoh4T2E0caqnUERERKTHq3e72VlU1qUrHf9n4TbeWuZZ6qJXRsvDDf0XOAH4xBYHnL/xcWGTe9xumk0Ie6IzTsxnz8GKgLK8XinNDud0OR2MGpjNH2+bQXpKItB0nQ//lTn//N2ZbNrVNdtnjMjP4v2Ve8nPTeuS5/VEYd28PtppTqGIiIhIz/fO8t388snlrNpU3HploKq6jpKjldTXu9ldXB6yToXfojBHyqt9x2u3l3Qu2B5ozJBerdb52oVjufLcAlKTG/ugLjl9OGdNGhhQb+JIz/DahoQvMy0pYNXPYKdP6E9OZjJpKYlMGt2HSaObX8m1rWZMzGfOzdMwQ3I6/ayeSkmhHwfqKRQRERHpiQ4cOc7BI8cB2H3Ak9jtP3ysTff+7vmV/PAvH/H8u1u464mlLFqzj/dX7gmo09z+cb9/blUnou6Z0rw9ef4GhthTcXh+Fn+8bUaLz/rahWMAQiaC08f1IzkpcF/AGy46gd996/T2hNsqh8Ph2/IjXikp9KM5hSIiIiI9052PLOaORxYHlLV1G/CGeW8rNnt6Fp94bQNPvmED6jhj+K/m4BVQAb589iiunz0WoMnefMl+G7h/07u1Q36fdH5546lNnpPgcvLjq6YAno3cg6UmeXoSz5o0oMm1vjlp/OX7ZwLwmTasIiodpzmFfjSnUERERCR6ud1u3O7QvUoNjlfVUuvdtH31loNMGtHbd630WDW//Nty+uak8vWLT6C6tp5cv0Vjio9UBjyrcH8Zj72ynu9+aSIfrIqN+X4/vmoK9z79CV88cwT/fn9bs/VOKuhD316pZKYlMmFELovXFQGeTpRzpw5i8boizjhxAFPH9OX2yycxYkAWKUmhU4tRg7JDJp4AyUku5t5xlu/v8FDm3nEW/fpmcfBg6KG90nlKCv345hRGNgwRERGRuFFdU0dtXX3IIYnB/vLSOpZvPNBsggGeLR4OHvUkd+99uptrzi/wXVuxqZiS0kpKSit5+MW1bNl9lHHDmp9HdvdflwE06YHsyXKzU3zfv1BJ4ZB+GQGreZ44yjNnLzcrmZLSKu67eTp9eqXy8+tPoX9vz5DLE4Y1Jt5zbp4WMOeyLVytdMO6nM5mh+9K14jhjvD20z6FIiIiIuF117ylvo3cW7M8aPP2wv1lfOuB9zlSXuUrczgIGDd6/ZwFbN59xHut8UKpN3FZt+NwByPvmVrLrX701SnN3Oe5sd57PrhvBokJTVOJvjlpFAxufSEaiS7qKfTTOKdQSaGIiISHMaYAeBLIBUqAa6y1m4Pq/B2Y6Fc0EbjUWvty2AIV6SYHDh/v8L1vL9/F8ao61mxrXAF0wSd7mswl/PXTn3LDRWMDX/dIx183Wl157mimj+/Pjn1l/O45z6bwKUkuKqvrfHVa628LXtjFd59vlX79nRyL1FPop3FOYYQDERGRePII8JC1tgB4CHg0uIK19hpr7SRr7STgWuAw8GZ4wxQJjyXri9i4s2nvnf9WEQ09f/Xe1QGXrNvvu/b28l3sKCprcv+rH+2g7Fj7hjVGk0tOH8bFpw0LeW3CSM8Qz14ZyaSnJFIwuBfpKQl889LxnDt1UGBlv67CS2cM5+ufPQGA08f3Z0pBXrOv3zCMNC1ZfUqxSD9Vf/oEREREwsgY0xeYDJznLXoW+LMxJs9a29wGazcA/7DWVjVzXaRHe+zl9QD85hbP3LUGh0obF4EpP+bZM3C/t5dxQ1ASWVNbT7D9h4+3uLBKNDn7pIH0ykzmhYXbmGLy+MQWk5uVQl0zS+RnpAXOx0xMcPLgd88APAvGnDVpIHNfWY/ddYREV2NSeMmM4b7jG7zJYXO+MmsUF5wyhMy0pI42S6KYkkI/DvUUiohIeA0G9lhr6wCstXXGmL3e8iZJoTEmCbgSOLcjL5abm9GJUD3y8jI7/YyeIB7aGW1tPHSsBjO0ccGSH89dwnP3XESSd/uDnJLG4Z7Z2ank5WWybW9p2ONsq9MnDmDR6r0BZYkJzpAJa8GQXvTPTWfhij0My8/ili+dSFpKItd/bgK/+8cnAPTqlcbxSk8yPHlMX06bMIA/z18Z8Jws7/clWP9+cPdN09m86whDB/ducr2t+vfr8K1dItr+z3aXSLRTSaGfhrG0SgpFRCRKXQoUWmtXtlozhJKSct9wu47Iy8ukuLjpsLxYEw/tjJY27iup8B3f/qcPeOyHZ/nOa+vcfPHOV/n2Fybwv092B/QGvvrBNhYHJVzR5roLTEBSeO9N0yjcX8YjL61rUve2L0z0bflw9fkFVJRVUlHm6Rmt8A55PVZRRan3OCc9ickjezOlIA+n08HMSQNZvGYf2SmuFn+ug3qnRsXPvSOi5f9sd+tsO51OR4c+AFRS6Eerj4qISJjtAgYaY1zeXkIXMMBbHsr1wLywRSfSBhWVNdTW1pOdkdx65SA/mftxwHmo4ZF//s+aJmUrtxxs92t1h6vOL+DptzY1KR83LKfJXoqJLicJrsDlPPr1TmP/oWOkpSQwa/JAJozMpa/fkFnwDPHcV1LBhBG9OVrhSQqnneDpsvvWFyYAnkSiYEBmi3v9ibRESaEf7VMoIiLhZK09YIxZCVwBPO39uiLUfEJjzCBgpreOSNT43oOLqK2r9+19V+92YwuPMHZo8/v//f65lbhCbEBfVtEzFoL583fPICnRyebdRwEYnp/FVecX8MsnlwPgDLHvXmKik+TExpU9r5s9hunj+vs6IxwOR5OEEGBgn3R+ccOpAKSlJDa7R6MSQukMrT7qx7f/inoKRUQkfG4BbjXGbAJu9Z5jjHndGDPVr961wCvW2vjaVE2i0px/fMo3fv8+ALV1njlydz7q2eD9f8t3c/+zK1ixufGzjV8+uZzXl+wEoLK6lrXbD7FqawnBesom8SnJLhJcTpK8+/T1zkpmeH6W7/pF04c2uSfR5WTs0Bwumj6UB26dwcyJA0hwOUlMCL0FhEg4qafQj9O3+mhk4xARkfhhrd0InBqifHbQ+T1hC0okyKHSStJTEn172G3a5dkS4q1ljSOdG/YbXLfjEADP/W8LE0bk8pO5Syg+Usn2faWcMrYvd/ylZyR+44blNLuxfUOv3IgBWXz1vAKmjfMM58zNSqaktIreWZ6htDddcgL/eGsTFZW1JCY4cTodfPHMkeFpgEg7KCn0ozmFIiIiIk3d/vBHZGckkeB0BGyE/s//bQ6ot2X3UVZ7ewAPHDnOwy+spfhI41YS0ZoQTh/Xj0OlVVhvsgvw7S9O5NdPf0Lh/vKAuvd8vfEzHIfDwTlTgvYB9DPthP6cMqYfVTV1TeYTikQT/e/041BPoYiIiMSxx19dz/VzFrB84wG27j0acO1oeTUlpVVUVNY2e/+9T38ScB4tC8I0p1+OZw7foLwMbv3ihIBryYkuBvZJByAjtXEfwPzc9Ha9htPpIFUbvkuU0/9QP5pTKCIiIvHso7WebREefnEtQLOLmvREU00ey/3WcPr1zdN4b8Ue3ly6CxyeRVwajB6UHXDv5eeMYnh+FjuLWt4qICU5AajSoi/S4ygp9KM5hSIiIhKv/PcMbHD9nAX0yU6JQDRd75ufn8DitUVs2HmYy88ZTVpKgm/bCJc3iRvaP5OdRWX86KopAJw7dTBL1u1n7NDe5GQmt9pL+J0vTWTZxgP0zoqN75nEDyWFfjSnUERERGLdjqJSNu0royA/M6A8eM/ABgePVoYsD4fLzh7J/He3tuueWz43zrdB/DknD2bCsN7kehPb6eP7M318f1/dz04fRnVNPWedNBCAO786maqaxjmTw/OzeKIdvaV9slO58NSmK4+KRDslhX40p1BERERi3S/+5tlL79Hbz2L+u1u4dObwgKGT0aRXenKL17924Rj+9t+NAWWnjO1HZXUdY4b0YlxBP4qLmx/ymZqcwFfPK/CdJye6AvYSFIkXWmjGj+YUioiISCy6fs4CfvPMpwFlH63dxzuf7OY/C7f59hqMNg4nXHuBYVBeRpNr50wZRFozC7icceIA+uakdXd4IjFDPYV+XN5x5XVR+otRREREYteBw8fIyUwhMaHjn9m73W5q6+o5cPg4h8urGD2ol6/na2PhkYC61TWev3eWbzzAgk/3dDzwbuR0ODhz0kDyc9OZ84/GpLZhAZyP1++PVGgiMUVJoZ8El2dT0RolhSIiIhJGVdV13PnoEk4Z25dbPje+3fe73W4Ol1XxyaZinn2nce/AgkHZXDd7bMh7nvXuMVh6rKZjQXeTL589iuff3QKAy+lJkAsG92LenbM4XFaFy9W4smd9vWd016RRfVi55SBTx/QNf8AiMSBsSaEx5kVgOFAPlAO3WmtXBtW5G/gmsNdbtMha+61wxQiQlOD0fXImIiIiEg4NH0iv236oxXrHKmtIS0mk6NAxstOTSE1OoN7t5sb73g1Zf9Puo2zfV+o7X7yuqOuC7oCs9CRKK6pbrDM8PxOnw0G9282k0bkB13IyA+cYNkz5SUtJiKntM0TCLZw9hddaa48CGGM+B8wDJoeo93dr7e1hjCtAUqKLmlolhSIiIhJdVm89yB/mr+b/XXkS9z2zgqH9M/nZ106mrJUk67FX1vuO5/odh9s5UwZx4shcfv/8qpDXH/vhWazfcRgzJIfffes0SkqrfD2FzTlxVB/65aQye5pW/BTpjLAtNNOQEHpl4+kxjDpJiS6qa+tarygiIiLSBvX1bv713tYWe8ha2w7rjY8LeX+lZyDVpt2eP6l2FpWxdlsJPWV5vDNOHBBw/sPLJ3HS6D6+8wSXk4kjPT2D2RnJjBiQ1eozM1IT+fXN0xnQp+X9A0WkZWGdU2iMeRw4H3AAFzRT7XJjzPlAEfAza+3i9rxGbm7T1anaIynBicvlIi8vs/XKPVw8tBHio53x0EZQO2NJPLRRpMH6nYd4fclO9pVUcOsXJ7ZY1+Fw4Ha7KdxfztD+mewrqeDnf1sWMLWl1m9E0++fX8Uvbjil22LviMkFeXy6qbhJef/eaVQcb5y/OHZYb0YMzOYbv3s/nOGJSAhhTQqttTcCGGOuBu4HZgdVeQS4x1pbY4w5D3jJGDPWWlvS1tcoKSn3TTruiKREF2UVVS3uaRML8vIyY76NEB/tjIc2gtoZS7qijU6no9MfAoqES0MnYEvTU/z/clmybj9zX13Ptz4/ga17jzZZ6+CVj3YEnN/1xNIuihSmmDyKDh1jT3FFu+4bNSibLd4ezG9/YQK7DpTzs3meuPJ6pZCRmkSCy4EZ0ivgPu0JKBIdIrL6qLX2KWPMY8aYXP+Ez1pb5Hf8tjFmFzAeCNtHSMmJLqo1p1BERES6iHcb5FaHiAKUH69h7queeX8frd1H35zU7gytib45qVx34Ri+/YcPfGU3fnYsj7+6IaBeekoCFZW1ANx93ckM6JPOTfe/57s+uG8GP7l6Ciu3HOSz04eRnNSY/P3yxlOprKr1nf/sayf7vkciEhlhSQqNMRlAjrV2l/f8YuCQ959/vYHW2j3e40nAMMCGI8YGiYlOqqs1p1BERES6hsOb8bQ0kOlwaVWTshWbDwbMuQuHS2cMJzHBxaC8dHYXV3DmpAFkpSU1qZfgcvLID85kR1EZQ/p5hoO7nA7q/Bo5cmA2IwdmN7l3YND8v6H9NZxcJNLC1VOYDsw3xqQDdXiSwYuttW5jzOvAXdba5cC9xpgp3jrVwNX+vYfhkJToouJYy6t4iYiIiLSV05sUhuopdLvdrNtxiN8/F3pFzhWbD3ZrbMESEzw9ep85ZQhPvLaBL545ks27jzSpN3vaUJISXRQMbhwOet8t0zlU1jS5FZHoF5ak0Fq7H5jWzLXZfsfXhiOelmj4qIiIiHTGscoadu4vZ/HaIq6bPYaGkZFlx2t4/NX1VFbX8e0vTABguS2A9tHhAAAgAElEQVTmLy+ujVywfi4+bZjv+PQJ+Zw+IR+Aeu+fRQPz0n1zDc87eXCT+3tnpdA7K6Xb4xSRrheROYXRLDHBqX0KRUREpMP85+Ndc4HxzZfbU1zhS6reXbGHs08aSPGR45EI0efskwbSOyuZkQOyGTM0J2SdE0flcs6UQVx82jAef3U9M4O2lhCRnk9JYZBkbV4vIiIiHVQfNET0SFlVyLmET71pmTkxn3+9tzVMkcG44b1Ztz1gOQcSE5xcNH1Yi/cluJx89bwCAL7/lUndFZ6IRJCSwiBJiS6qa7TQjIiIiLRfXV3gB8u/eXZFs3Vr68L7IXRqctM/+1xOLfspIkoKm0hMcFIT5l/SIiIiEhv+uWBLwHnJ0UqaW3T0cJgXZclITeTcqYNITnTx2uKdAEwd0zesMYhIdFJSGCQ50UVNTT1ut9u3hLSIiEh3McYUAE8CuUAJcI21dnOIel8Gfgo48Ox1fq53ITeJkBWbillmD1AwqBdnnTQQgA9X7wuo09LOhGu2lrRwteNOn9CfRWsaF2+/cNoQ/rukENxurjzXAPiSwuH5Wd0Sg4j0LEoKgyQlunADtXVuEhOUFIqISLd7BHjIWvu0MeYq4FFgln8FY8xU4G5glrW2yBiTDWjt/wh78D9rAFiybj9nnTSQisqadq1LENyr2FkP3DoDt9tNr4zkgKSwT3ZqyPpD+2l/QBHxUFIYJCnRCUBNbT2JCc4IRyMiIrHMGNMXmAyc5y16FvizMSbPWlvsV/V7wG8b9u611h4Nb6Txq6q6jndX7KH46HE+N2O4byP3D1bvbVL3Vr9VR8Pt7utOJju96SbzV5472pf8+a8uOu//zqfyWGXY4hOR6KakMMjGHYcBWG4PcIaWXBYRke41GNhjra0DsNbWGWP2esv9k8ITgO3GmIVABvAf4B5rbUujE5vIzc3odMB5efHRu9TQzof/vYr/frQDAKfLyXcvn8wTL6/lxfcDVw3dvK8s3CEG6JuXGfCz+etPz2fD9kPM9A5rfeaXeWSmBSWNOaF7EGNNvP2fjWXx0EaITDuVFAbZvPsIALbwsJJCERGJFi5gIp4exSTgDaAQ+Ht7HlJSUk59qP0R2igvL5Pi4sgmP+Hg386Dh475yisra3j+zQ1NEkKAeS93/wb0IwdmcemMETz2yjrKjtUw5+Zp/GH+aooOHePw4QpSggY4jRmUFfDzqqxoHHEcjz/LWBYP7YyHNkLn2+l0Ojr0AaDGRwY5Z+pgAAb17fynqSIiIq3YBQw0xrgAvF8HeMv9FQL/stZWWWvLgJeAU8IaaZzyT6EXrSniqbc2hay3/3DXbkJ/treHr8FXzyvgJ1dPZdzw3vz8+lP46nkF9M1J49YvTuCcKYPo1zutS19fROKLegqDnDV5EM++ZemVkRzpUEREJMZZaw8YY1YCVwBPe7+uCJpPCPAMMNsY8xSe9+5zgH+FNVgJq6+eV8DnzxhBydFKjlZUMWFEru9ar4xkzpkyCID83HTfxvIiIh2lnsIgCd7FZWzh4QhHIiIiceIW4FZjzCbgVu85xpjXvauOAvwTOACsB1YC64AnIhBrzCk/XsMPHlpE4f6mw7VeXrTdN60k3JxOBxmpiQztn8nEkX20TZaIdCv1FAZJSnABsHDVPr524dgIRyMiIrHOWrsRODVE+Wy/43rg+95/0oXWbivhcFkVry/ZyS2fG+8r//3zK1m77VBYYpg6pi952Sn89+PCsLyeiEgw9RQG0TYUIiIi8eGhF9bw5BsWgKUbDnDzb9/zXevqhDAjNTHg/KLpQ33Hbreb6eP6A/CDyyfxnS9N7NLXFhFpjXoKgzTsUygiIiKx7ZOgqZsNG8+73R1fobU5c26ezuGySn76xFLAkxRu2nWEzbuPgtuzwN28O2d1+euKiLSFMqAgCS59S0REROJVTW0duw+Ud8mzThnb13eclpJAcqLLd57gcnL+yUMAqO+GJFREpD3UUxjE4XDQr3caKX6/uEVERKRnqq6pY822EqaYxgRt3usbAvea8POH+atJ7OTfAPm5aVzzGYMZksPSDQt85X16NW4W73Q4cHrXjlFOKCKRpqQwhH45qV2+35CIiIiE3z8XbOG9FXv48dVTGDUwG4APV+9rtv6GnZ1ffXzGxHzMkBwAzpkyCJezceXQP31nJnuKy3E6HfTP9ewtOGFkbsjniIiEi5LCEOrdbvYfOhbpMERERKSTSo5WAvDRmn3c+9QnPPS9M7r9Nf17/oL3EMxITfQljPm56fzpOzNJT9GfYyISWZpAF0JuVgoAtXX1EY5EREREOqquvp76es97+Xsr9wKwr6T7P/Rtz0I1GamJ2oNQRCJOSWEIg/IyADhWVRvhSERERKSj5jz9Ket2BA4Hra/v3AS+fr09Qz6//YUJfPHMESHrpKckhiwXEYlWGq8QQlqy59tyvLKWrLSkCEcjIiIiHbF1b2mTslVbD3bqmb+4/mT2HKxgWP8sII/XFu+ksrouoM4ZJw7o1GuIiISbegpDSPBuYL94XVGEIxEREZGu9NrinZ26PzHB5U0IPX581RQmjerjO7/p4hNwOjUcVER6FiWFIZRWVAPw8qIdkQ1EREREIu608f2bvTaobwaXnzMKgDMnDWDauObriohEKyWFIZw8xrOX0ZSCvAhHIiIiIpH0lVmjuPGzJ7RYp29OGv93zVSuPLegxXoiItEqbHMKjTEvAsOBeqAcuNVauzKojgv4E3ABnm1l51hrHw9XjA2y0pNISXKRk5Uc7pcWERGRTjpeVcvxLlosbmCfdAC+cel4BvfNaLbeiAFZzV4TEYl24Vxo5lpr7VEAY8zngHnA5KA6XwVGAaOBXGCFMeYda+2OMMYJQEqSq8nEcREREYl+v376U3YXl3fqGQWDe3HFOaMZ2j8TaBxFJCISi8I2fLQhIfTKxtNjGOwrwFxrbb21thh4EbgsHPEFS01OUFIoIiLSA3UmIUzyLjZ38enDfAmhiEisC+uWFMaYx4HzAQeeIaLBhgD+y4IVAoPb8xq5uc0P7WirvLxM9pUcY1/JMfLyYvcNIZbb5i8e2hkPbQS1M5bEQxslMp59Z3O77znjxAEsXLUXB/DI7WeRl5dJcXFZ1wcnIhKlwpoUWmtvBDDGXA3cD8zu6tcoKSnv1Ma0wW8EsfqmEC9vePHQznhoI6idsaQr2uh0OrrkQ0CJLZ9uKubt5bvafd9lZ4/0JIUObSUhIvEpIquPWmufAs42xuQGXSoEhvqdDwHa/9u9C/jvOSQiIiLR42h5FU+8up7qGs80j70HK3h7+S7+/J81HXqe05sMKicUkXgVlqTQGJNhjBnsd34xcMj7z9984OvGGKcxJg+4FPhXOGIM1q93KgBud8d7HUVERKTrPffuFhatLWK5PQDA/z3+cbuHjV4+y7O34B1XnOTbbF49hSISr8I1fDQdmG+MSQfq8CSDF1tr3caY14G7rLXLgaeAU4GG3+y/sNZuD1OMARatKQLg4/X7tRGtiIhIFDl4tBJofxI3KC+dBJeTiSNzOf+UIZx/yhAAamo9a9/laisqEYlTYUkKrbX7gWnNXJvtd1wHfCMcMbWm/HgNAMXeNx4RERGJDlt2exY0dwC1daEWMw/te1+eRE5m08QvMcHJTRefQMHgXl0VoohIjxLWhWZ6EocD3O7GTw9FREQkyjjg5UWtDygaM6QXF5w6NGRC2ECjgkQknikpbEZigpPqmnpqlRSKiEg3M8YUAE8CuUAJcI21dnNQnbuBbwJ7vUWLrLXfCmeckVBXX8/SDQc49YR+/PbZFQzLz/Jde+zl9W16xmVnj2K4330iIhJISWEzcjJT2H/oGG600IyIiHS7R4CHrLVPG2OuAh4FZoWo93dr7e3hDS2yvv6b9wCY+4onAdxYeCSC0YiIxKaIbEnRE9x8yQkADMrTPlgiItJ9jDF9gcnAs96iZ4HJ3lW4RUREup2SwmZkp3vmHdS0YwK7iIhIBwwG9ngXW2tYdG2vtzzY5caY1caYt4wx08MZZCS8u2JPpEMQEYkLGj7ajMQET76sOYUiIhIlHgHusdbWGGPOA14yxoy11pa09QG5uZ0f/ZKXl9npZ7RFZVUtT71p233f0z+/gKt+9gYAIwdls3X3UXJy0todd7jaGUnx0EZQO2NJPLQRItNOJYXNSHB59j5ST6GIiHSzXcBAY4zLWltnjHEBA7zlPtbaIr/jt40xu4DxwPttfaGSknLq6zs+Vz4vL5Pi4rIO398eG3ce7tB91cerAZgxIZ9dB8oBOHz4GMUpbf+TJ5ztjJR4aCOonbEkHtoInW+n0+no0AeAGj7ajOREFy6ng4rjtZEORUREYpi19gCwErjCW3QFsMJaW+xfzxgz0O94EjAMaH9XWg9R725/8nrTxZ71AObdOYvrLxrb1SGJiMQs9RQ2w+FwkJ6S4NvEXkREJBRjzAt4tpN4zVrb0TeNW4AnjTF3AYeBa7zPfh24y1q7HLjXGDMFqAOqgav9ew9jTQdywmb3GnQ4OhmMiEiMU1LYgpSkBKpr6iIdhoiIRLcPgLuAJ4wxzwNPWWs/as8DrLUbgVNDlM/2O762s4H2FGu2lfDA86vadc/EkbndFI2ISOzT8NEWJCe5qKxWUigiIs2z1v7eWjsZOAM4AjxrjNlsjLnLGDMywuH1SK98tKPd98ycOKBJ2VXnFzA8P4uBfdK7ICoRkdilpLAFSQlO1u84FOkwRESkB7DWrrPW/gi4CjgG/Az41BjzjjHmxMhG17Mcr2zffP7ffet0poTY1nHkwGx+eu1UEhNcXRWaiEhM0vDRFmzdWwrAtr2ljBiQFeFoREQkWhljDJ5k8Eo88/2eAj4LFAPfBF4EhkcswB7k003F7DlY0a57sjOSuikaEZH4oKSwDY6WV0U6BBERiVLGmOV4VgJ9DrjSWvtxUJXfG2NuDXtgPVBNbT3z393Sprrjh/dm7fZDfH7mcJxaSUZEpFOUFIqIiHTOHOBla211cxWsteolbMH6HYdYtKaIxevatpjq1Z8xnDVpALsOlDOob/v34xIRkUCaU9gW+gBSRESaV4qnp9DHeJwXmXB6jt3F5dTU1vPbf65sMSHsk50ScD6kXwYOh4Mh/TLVSygi0gWUFLbB/kPHIx2CiIhEr4eAsqCyMm+5NONIeRV3PbGUHz+2pNW6n585IuA8MzWxu8ISEYlLSgrb4Pk2zm8QEZG41Ndauy+obB8Qeid1AeCYd4XRktLKFuvNmJBPrrencFj/TO6+7mT65qR1e3wiIvFESWELfnLNFABOG6/3dRERadY2Y8ysoLKzgO0RiCWm/OrGU7n+orG+84QEJ0P6ZUYwIhGR2KSFZlowckA2yYkuMjRMRUREmnc38B9jzBPAVmAkcJ33n3RC35xUADLTPO/Dw/treygRke6gnsJWpCa7OFbVvk10RUQkflhrXwLOB9KBi7xfP+MtlxDcbjdtWR+mYRGZ/Nx0fnrtVC47e2Q3RyYiEp/UU9iKBJeTurr6SIchIiJRzFq7FFga6Th6gnv+vpyte0vbVNc/cRyer15CEZHuoqSwFdW19ZQcbXkSvIiIxDdjzCRgJtAHv42MrLV3RSyoKNVaQjhjYj4Vx2tYsfkgDm03ISISFkoKW1FaUU1pRTV7DlYwsE96pMMREZEoY4y5CXgAeAu4EPgvnuGkGj7aAedOGaTFZEREwkxzCttoZ1HbhrqIiEjcuQO4wFr7eeC49+uXgJrIhhV9amrrWq1TV+8OQyQiIuKvzT2FxpizgR3W2u3GmHxgDlAP/MhaW9TKvbnAU3hWZKsGNgM3W2uLg+r9DTgXOOgtmm+tvaetMXant5bt4rTx+ZEOQ0REok9fa+0H3uN6Y4zTWvtfY8w/IhpVFFq28UCrdfJztQehiEi4taen8GGg4SO+3wGJeJLCx9pwrxv4jbXWWGsn4Fmye04zdedYayd5/0VFQghQuL880iGIiEh02m2MGeY93gR8zhgzE8+HoOK1s6iMx1/dEPLaxJG5AGSkJpKSpJktIiLh1p7fvAOttYXGmATgM8BQPG94e1u70Vp7CHjPr2gJ8I12vHbEnHXSQN5bsSfSYYiISPT6DTAW2AH8AvgXkATcFsGYos6mXUeaveZ0OHjg26eTmOAKY0QiItKgPUlhqTGmHzAeWG+tLTfGJOHpMWwzY4wTT0L4cjNVvm+MuRlPb+KPrLWhP1ZsRm5uRnuqh5SX1zjBffyoPr6k0L88FsRae5oTD+2MhzaC2hlLYqWNxhgHsBAoBPAOG80Bkqy1GmLiJzEx9OCkpEQns6cNJTsjOcwRiYhIg/YkhQ8Cy/B8+vldb9npwMZ2vuaDQDnw5xDXfgLss9bWG2OuAd4wxoyw1rY+M92rpKSc+k5MUs/Ly6S4uMx3PrJ/4x8u+4qOkuCKjbV5gtsZq+KhnfHQRlA7Y0lXtNHpdHTJh4CdZa11G2PWAJl+ZdVo6GgTyc30Aj7yg7PCG4iIiDTR5gzHWnsfnkVgTrfW/tNbvAe4sa3PMMb8FhgNfMVa22RHeGvtnoZya+3fgQxgUFuf3x2y05N8x0+9aSMYiYiIRKkVQEGkg4hmKzYXM/fV9ZEOQ0REmtGu2dzW2k0Nx97VSOutte+35V5jzL3AFOAia21VM3UGWmv3eI8/g2dhm6iZ0LfcFnPd7LGRDkNERKLLe3hGtvwN2IVncTUArLXzIhRTVHnw32tClj/x/84OcyQiIhJKe7akeB/4sbV2kTHm/wHfB2qNMQ9Za+9t5d5xwI/wrMr2kTEGYLu19vPGmJXAbGvtXuBJ77zFeqAUuMRaW9uhlnWD41VRE4qIiESP04HtwJlB5W4g7pPC6+csaPaaw+EIYyQiItKc9vQUjsezaijA14GzgTJgEdBiUmitXQeE/M1vrZ3kd3xuO+IRERGJOGttp7u7jDEFwJNALlACXGOt3dxMXYNnyOrD1trbO/va3WnvwYpIhyAiIm3QnqTQCbiNMSMBh7V2PYB3lbWYdsaJA1i4qtWdN0REJA55V9UOKdT8+WY8AjxkrX3aGHMV8CgwK8RrubzXXuxIrOHyzDubeGf57hbrnDAs5v98EBHpMdqzlOaHeFYM/S3wAoA3QTzYDXFFlYLB2b7j8uM1EYxERESiUC1Q08y/Vhlj+gKTgWe9Rc8Ck40xeSGq3wm8imc6RtRqLSG886uT+dbnJ4QpGhERaU17egq/BvwAKAbu95aNAf7YxTFFnSS/ZbRf/GAbV51vIhiNiIhEmeFB5/l4krdX2nj/YGBPw/ZL1to6Y8xeb3lxQyVjzInAZ/BM3/hpRwLt6r18O+r0yYM7/YzuFit7abYkHtoIamcsiYc2QmTa2eak0FpbAvw4qOy1Lo8oCk0a3cd3vODTPew9WMEdV06OYEQiIhItrLU7g4p2GmOuxbO37xNd8RrGmETgMeA6b9LYoed09V6+HXHvTdOifi9O7RcaO9TO2BEPbYTOt7Oj+/i2Z/XRROD/gKuBAcBe4CngHu9GvTEreMP6jYVHIhSJiIj0EFlAqOGfoewCBhpjXN6Ez4XnfXaXX518YCTwujch7AU4jDFZ1tqbujDuTttTXN7stTuuOIn+vdPCGI2IiLRFe4aP/gY4BbgF2AkMxTN8JQv4XteHFl1uvmQcj768LtJhiIhIlDHGPIXf3oRAGnAG8HRb7rfWHvBuz3SF954rgBXW2mK/OoWAb9iKMeZuICMaVx9dva2k2WtjhmpxGRGRaNSepPAy4ETvMFIAa4z5FFhFHCSF44b3jnQIIiISnbYEnVcAj1hr32nHM27Bs1fvXcBh4BoAY8zrwF3W2uVdEmkYOELvQCUiIlGsPUlhc7/l4+K3f4IrLpopIiLtZK39eRc8YyNwaojy2c3Uv7uzrxlOP7h8En17pUY6DBERaUZ7ksL5wCvGmJ8DhXiGj/6ftzzmBc8rFBERATDG/An4p7X2I7+y04AvW2u/G7nIIsNN04VsRg3IJjnJFaK2iIhEg/ZkOncA7wAPAZ8ADwLvAj/shriijssZ2FO4ZH0RbnfHV3ATEZGYcQUQPLzzE+DKCMQSMcerarl+zgLmv7u1yTWXRtuIiES1FnsKjTGzgore8/5z0DipfgawoKsDizYOh4MbLhrLE69tAOCxl9dTU1vPzIkDIhyZiIhEmJumH7K6QpTFtOcWbG72WvAHqyIiEl1aGz7a3P5KDQlhQ3I4ossiimJ5QfMhDh6pjFAkIiISRT4AfmWMucNaW2+McQJ3e8vjxsJV+wLOh+dnsn2fZ68th0NJoYhINGsxKbTWDg9XID3BoLzAjSArKmsiFImIiESR7wCvAvuMMTuBIcA+4OKIRhVh3/vyJG77Y1zlxSIiPVZcDW3prLSUBB75wZm+84/WFnHg8LEIRiQiIpFmrd0NTAY+B9wPXApM8ZbHhdVbDzYpy0hNjEAkIiLSEUoK2ykpsXH1tMrqOh5+cW0EoxERkUgzxkwCBlprl1hr51trlwADjTEnRjq2cPnD/NUhy6eavDBHIiIiHaGksAPuvWma77i2zk358RqtRCoiEr+eBoK7xZKApyIQS1Q4d+ogAG65dDxz7zgrssGIiEirlBR2QHVNne/4UGklt/3xA95cuiuCEYmISAQNsdZu8y+w1m4FhkUmnMi78twCAJwOBy6n/tQQEYl2+k3dAf4LzlRWexLETzcXRyocERGJrN3GmMn+Bd7zvRGKJ6LGDOkV6RBERKSdWtuSQkJwOh0M65/JjqIyX1llVS0LPt3NaeP7k5Kkb6uISBx5AHjJGPMbYCswErgduCeiUYVJbV19wPmAPukRikRERDpKPYUdVF0b+Ca4u7iCp9/axNxX1kcoIhERiQRr7Vzg+8BFeFYfnQ38wFr7WEQDC5P1Ow4HnGuKvYhIz6OksIPOnTIoZPmKzQepCUoYRUQk5i0EHgZ+B8wHsowx10c2pPD4w/xVAef1ygpFRHocJYUddNZJA+mVkRTyWk1tXchyERGJPcaYS4EtwM+BR4BbgUeBqyMZV6TU1yspFBHpaZQUdsKvb54esnzt9kNhjkRERCLoV8D11tqTgArv15uATyIbVnhNHJkLgMMR4UBERKTdlBR2QnKiiykFTTfmffqtTRyvqo1ARCIiEgFDrLXzg8qeBK6JRDDh5N8rOHvaUGZNHsiXzhoVwYhERKQjlBR2Uqi5E+XHa5j3+oYIRCMiIhFwwBjTz3u8wxgzHc8KpK4IxhQWdfWNc+hTkxO46nxDRmpiBCMSEZGOCMveCcaYXOApPG+S1cBm4GZrbXFQvTTgr8AUoBa43Vr7ajhi7Kjm5tPvP3Q8vIGIiEikzAVmAP/Gsz3Fu0A9nkVnYlpNbeObYGKCPmcWEempwvUb3A38xlprrLUT8OzjNCdEvduBUmvtKOBi4HFjTEaIelFvd3E5ry3egVursImIxDRr7X3W2n97j/8OFABTrLU/jWxk3W/hqr2+45SkmO8YFRGJWWFJCq21h6y17/kVLQGGhqj6FTwrtmGt3QwsBy7s9gA74aLpQ5sdKvPv97dxpLw6zBGJiEgkWWsLrbVxMYdg/ntbfMe9MpIjGImIiHRGWIaP+jPGOIFvAC+HuDwE2Ol3XggMbs/zc3M737GYl5fZrrrTJnn2LHztw2088sKagOtJqUntel44RWtcXS0e2hkPbQS1M5bEQxvjgQbDiIjEhrAnhcCDQDnw5+54eElJeaf2SMrLy6S4uKxD955i8ngkqOz+p5YxrH8Wp43vT8HgXh2Oq6t1pp09STy0Mx7aCGpnLOmKNjqdji75EFC6xm1fnBjpEEREpBPCmhQaY34LjAYuttbWh6hSiGdYacMCNEPwTNjvMZITXVTVNG5eX7i/nML95SxctZd5d86KYGQiIhKNjDEFeLawyAVKgGu8Uyj861wHfA/PAjYuYK619k/hjrU5k0b3iXQIIiLSCWFbKswYcy+eVUUvtdZWNVNtPnCzt/5o4GTgjfBE2DUe/O7MSIcgIiI9yyPAQ9baAuAhvHPrg/wbONFaOwk4DfiBMUbdcyIi0iXCkhQaY8YBPwIGAB8ZY1YaY17wXltpjBngrXo/0MsYswV4FbjJWtujxlEluJz0yU4Jee1wWRUVlTUh9zYUEZH4Y4zpC0wGnvUWPQtMNsbk+dez1pZaaxvePNKARDwre0fM/sPHIvnyIiLShcIyfNRauw5wNHNtkt9xBXBZOGLqTjdcNJb7nlnRpPwHDy0C4PyTB3P5OaPDHZaIiESfwcAea20dgLW2zhiz11sevJfvJcCv8ez5+yNr7Zrgh7WmKxdjW7ntEAB9eqXG5MJBsdimYPHQRlA7Y0k8tBEi085ILDQT88yQHC47eyRHy6t5a9muJtffWraL0yfkM7ivFkkQEZG2sda+DLxsjBkCvGiMed1aa9vzjK5cjC3Z5fms95rzC2JucSQt+BQ71M7YEQ9thM63s6MLsYVtTmG8ufDUoS32Bt7916Vs21sasCiNiIjEnV3AQGOMC8D7dYC3PCRrbSGwFPhsWCJsxpEyz/IAydq0XkSkx1NS2M2mj+sfstzthl/9fTnzXouL/Y1FRCQEa+0BYCVwhbfoCmCFtTZ46OhYv+M+wNlAu4ePdqW5r64H4FhlbSTDEBGRLqCksJtdf9GYFq9v3Xu01WfsPlBOZbXedEVEYtQtwK3GmE3Ard5zjDGvG2OmeuvcZIxZZ4xZCfwP+LO19q3IhBtIa6eJiPR8mlPYzVxOJ6eP78+itUUhrx8qreL9lXuYMCKXtJQEauvcZKQm+q5X1dRx17ylnDS6D7dqc2ARkZhjrd0InBqifLbf8ffCGpSIiMQVJYVhcMNnT2DUoGyefCP0egBPvmHJzkiivt5N2bGagE3ut+8tBWCr96uIiEik+c+HT3CFXFxcRER6ECWFYTKsf1aL14+WV4csf3u5Z60BDR8VEYxOoUYAACAASURBVJFoUVdX7zseN7x3BCMREZGuoDmFYTK0fyYPf/8M5t05i9ys5DbfN2ZoDgDVNfXa9F5ERKJCbV3j+5HDoZ5CEZGeTklhGKUkeTpmb7/8pBbrzX1lHe8s30VdfT3VfkN0mutNFBERCafqWs9708SRuRGOREREuoKSwgjo1zuNsd4ewFAWr9vPM+9sZv67Wzla0ZgIPu5d/ltERCSSFq7aB0DZMX1YKSISC5QURsgPr2i5txBgy56jHK9qnEu4YedhXlm0nZra+hbuEhER6V59e6UCcOrYfhGOREREuoKSwii2bW8p1TWBCeALH2znrWWFEYpIREQEnluwGQAzpPlRLyIi0nMoKYygn1wzpdU6yzYeaFJWWV0XoqaIiEh4VFR6RrG4tB2FiEhMUFIYQSMHZPOHW2dwyenD2nVfXZ1WIRURkchzOZUUiojEAiWFEZaVnsTF7UwKj1XVcv2cBcx7bUP3BCUiItIGLpf+jBARiQX6bR4FXM72/RgWrtoLwIdr9nVHOCIiIm2SkuiKdAgiItIFlBRGiZaG4MyYkN/stVc+2sGe4nLe+LgwYKVSERGR7paRmhjpEEREpAskRDoA8Zh7x9nUu908v2ALY4bksHN/GS99uB2AnMzkZu97YeE2Xli4DYBdB8r5+sUnhCVeERGJX1MK8thVXI5TcwpFRGKCksIo4nQ4uPyc0QAk+K3odsGpQ0hwOXjhg+0t3r94XRFfnjWK7PSkbo1TRETi2yebiiMdgoiIdCENH41Sg/tlAp5ewtTkBC6cNpSzJw9s9b7vPfghCz7d3d3hicj/b+/O46Oq7j6OfyaTlQQChAAhLJHtgCyy44IoWK3V+tStFXdFu6gttZUq+jwurV1o1aq4AGpp3aqtWnGpa4siiIjIjnDYIawJISGE7Jl5/pjJMEMSSEIyk9z5vl8vX84959w753BJDr97zj1HRERExCEUFLZQqcnxzJk2kUduOwOAWHcM155n6nXuSx9tCHwuKaskJ78Y8E0vXbhKi9OIiIiIiMgRCgpbmftvGF2vcpOnz2PBqt3c9uhnTJu9mAOFpdw/Zwlz3vNtY1FWUUVFZVVzVlVERBzI69VeuSIiTqOgsJXp1bUt54zoXq+yf31vfeDz1KcXheRdPu1dps1e3KR1ExER5yvWStciIo6joLAVmjAik4QT2BvqkVeXA5B/qKypqiQiIlFiwUrfawiJ8dqjUETEKRQUtkLdOiUz846zmDppWKPOX7stv4lrJCIi0aJ6T9yycr2CICLiFGHbksIY8zBwGZAFDLHWrqmlzAPArcBuf9Ln1trbwlXH1ubkrI589/RevLtoe6OvsSfvMBlpyU1YKxERcbJ2/m2Pxg7qEuGaiIhIUwnnPoVzgceBBccp94K1dmoY6uMIpkcH3qXxQeH/Pvsll4zvzZiBnUmMc5OdW8Tgk9KasIYiIuIk1a8vXHJm7wjXREREmkrYgkJr7UIAY+q3rYLUz8lZHbjl4sHMnFtj4LXe3vxsC29+tiVw/NQvxpOUEPpXI/9QGR8vzWbzroNMu3oELper0d8nIiKhjDH9geeBNCAPuM5au/GoMvcCk4AqoAK4x1r7YbjrWunxAL6tkkRExBnCOVJYX5OMMecBe4H7rbVfNOTktLSUE65AenrbE75GOF3QuR0z564hId7dJO94xCbGkd4p9M/x5zMWcqi4HIDKmBi6dTrxP+dwaW33szGioY2gdjpJNLSxgWYBT1lrXzLGXAPMBiYeVWYJ8Ii1ttgYcwow3xiTYa0tCWdFc/N9Xxfr1sNBERGnaGlB4Szgd9baCmPMucBbxpiB1tq8+l4gL68Ij6fxeyilp7clN/dQo8+PlHuvH0X7lATueOpzJo7IpEPbBN6Yv+X4J9Zi64589uwtpGO7RPbkHWZPXnEgIATIP3CYuFayT1VrvZ8NEQ1tBLXTSZqijTExriZ5CNgSGGM6AyOAc/1JrwBPGmPSrbW51eWOGhVcBbjwjSzuDFddAd7/cgcA7hiNFIqIOEWLCgqttXuDPn9sjMkGBgPzI1er1uGkjHYAzJl25MHyOSO78/Sba1iz9UCDrjX95WXHzP+/577kF98/hYFZHRteUREROVoPYJe1tgrAWltljNntT8+t45zrgM3W2rAGhME0Uigi4hwtKig0xmRaa3f5Pw/Dt1KpjWilWrHE+Nga7wY2hcoqLw+9uiIkABURkfAwxpwFPMiRkcV6a8rR1a5dU3HHODcwjIYpztHQRlA7nSQa2giRaWc4t6SYAVwKdAX+Y4zJs9YOMsa8B9xnrV0K/N4YMxLfS/TlwLXBo4fScF07tqk1/bU/XMijL3/NojWN/+N98l+r+emlQ9iXX8zMuWuYOmk4KUlxNcpVVHrwer3Ex2mjYxGRWmQDmcYYt3+U0A1086eHMMacBrwEfM9a2+CHpk3xikW1A3lFjb5OS6dp3M6hdjpHNLQRTrydjX29Ipyrj04BptSSfkHQ5+vDVZ9o8T/jsoiPiwl5v3DMwM4kxsfSt3vqCQWFyzbkcqCwlOffX8+OfUUs25DL+FO6UVhczuGSisD+h/c8s5i8wlKNLIqI1MJam2OMWQFciS/guxJYHvw+IYAxZjTwD+Bya+2x5/mLiIg0QIuaPipNzx0Tw4WnZTFxRHc27izgsddWMXagb8Phvt1ST/j6U59eVCPt7tmLKSmrZOYvzyIh3k1eYWmd53s8Xr7ZfkB7I4pItPsJ8Lwx5j4gH987gxw1m+ZpIAmYHbS907XW2tXhrGhSgpteXaJjCpeISLRQUBglkhJiGdqnE0/efiZtEn1TPLt3TqF7ego7c5tmCtB7X2wnLTWRkrJKAGa/vZYplw8NKXPHU5/TpUMSd141AoB/L97Om59t4Zc/OIXBvRUYikh0stauB8bWkh48m2Z0WCtVC6/XS3mFh95N8FBRRERaDq0nHWWqA8Jqd109nGlXj2iSa+cUlPDIqysCx+u25zPl8QWB48oqD/mHyli/o4Atuwspr6gK7HeVf6jsuNffkF1Ado5z32EREWnpSsurqPJ4SU7SM2URESdRUBjlkhPj6N+jPeeO6hFIG96vU61lh/Zp2EheWUUVRSUVgeMP/HtbAfz2haU89tpKXP6F67btO8TGnQXHvN70l5dx/5wlDaqDiIg0nb15hwGaZWVrERGJHP1WFwCu/FY/vj2mBx6vl/0FpSzfuL9GmQtO7cUo05k5761r1Hf867MtIcfrdxRwoNA3QvjJsl18smwXP/neILIy2tEpNZGtewrp45+i5PE2frU8ERFpGlNn+GZ/JMZrNWkRESdRUCgBHdslAtApNYmpk4bhhZDpoADjhmY0OiisTU5BScjxrLfWAtCuTRyFxRVMu3oE/Xu05+Y/flLr+au35NGveyqJ8fqrLCLS3KqqPACkJNbcfkhERFovTR+VWp2c1ZFBWR352aVDAmnVT4avmNi3RvkZPz+zSb+/sNg37dTuyGePf7rS0XILSnj0nyu59c+f4dVIoohIs5sw0veqwaCTOka4JiIi0pQUFMoxDe+fzsw7zmLKZUPp6V+C/PTBXWuUi6l+ObCJvblgK//77Je15s1fsTvwedmG3FrLiIhI03G5oEPbBFzN9DtfREQiQ3Pu5LgS4twMC1p8pm2b+JD8y87qTZvE2v8qTZrYl4FZHZt0gZjJ0+fVSMstKGVDdgFerxfTswPgew+xtLyyyb5XRCTaVXm8uGMUEIqIOI2CQmmU6v0NH7rldDq2SwjJ+8GEvvzzk01cfW5/zhnZPSz1mb9yN//8ZBMAc6ZNxOv1Bt5D7JPZjrOHZXLGkIyw1EVExKmqqrzNNjNEREQiR0GhNMq0q4dzoLCMtNTEGnnnj+3J+FO61Tl62Bz2HSgOOV78zb7A5827Ctm8q5DPV+/h598/hYS4I6vmPfvOWob1S2f0gM5hq6uISGs1f/nOSFdBRESagd4plEZpkxhH984pIWnfn9CHb/lHBo8OCH8zeQy/vXlsrde67tumSes2efo8nn3nmxrp63cU8Lf31/P3jzcE0r5Yu4+Zc9eElPtm2wFe+GB9k9ZJRKS1e3/x9khXQUREmolGCqXJfGdsrzrzjg4gwbeaaWl5FacN7soLH9rmrFrAl/4RxKvO7V8jb19+MZVVXh72b8OxYedBfnvzWHILSkhJitNmzSIS1V77dHOkqyAiIs1E/8qViLn7mpF0aJsQMp0znDye0G0s7p69OOR4937fVhh3zfqCkzLacu/1o8k/VMYdT33ObZcMZqTRlFMRiT4ThmdGugoiItLENH1UIuLZO8+mR+cUUpJCN0CubWGa6843/OFHpzbp9z/22kpuf2Jh4Lg6ADzay/6pplv3HAJgZ24RAG8t3MpNf5zHmq15FBaXA7Bmax5FJb79FXfmFLFp58HAdYpKKnjpI0tFpadJ2yEiEm7p7ZMiXQUREWliCgolItwxoX/1Yt0x9OralqvP7c+V3+pHUoKbnl1SGNCzPWcPy6RLxzZN+v2rNh8J4AD+77na90L879dHFlX48cOfBkYXd+YexuuFP/9jJbfPWEhJWSV//sdKnnhjFQD3zVnC71/6msoqXxD4xvzNzFu2i8Vr97JmSx676ghC61JWUUVZeVWDzhERaQ7akUJExHk0fVTC6sGbx7KnloDomV+dHfh87qgenDuqR40yPTqnkJ1TREpSXEhAFy4VlR4ef31VrXn/8QePR6+C+uGSHVx4WhaV/hFCl8vFn/+5EvBtnVFfUx5fQEWlp0HniIg0B5eiQhERx1FQKGGV2SmZzE7JjTr3/htHU1ZeRWK8m1Wb8wIB2sxfnkV8XAx3zvyCvMJSOqUmsv9gaVNW+7je/GwLAIXFFRSXVgbSDx72TS2t8vpGGGMaOTavaaci0lJon0IREefR9FFpNWJcLpISYnH5/w8wZmBnEuLduFwukpN8abddMoQbvzMAANOrQ9jr+dPHPgt8zskv4YG/LmHxWt+qp8+9uy6QV1HpYfOug4EppsGqPB7e/GwLJWWVNfJERCIpRiOFIiKOo5FCaZX6dU/lynP6cdrgrjXyvHgZNaAzX67bx+1XjmTBsmy8Xi8vfbShlis1r1Wb8+rM+/HDnwK+lfyu9e/V+MIH68lIS6ZtchzvLNpGUUlFIA+gsspDrNv3LMfr9ZJbUEJ6etvma4CIyFE0UCgi4jwaKZRWyeVyce7oHiGrl1ZPS02KjyUpIZapk4aT0SmZCcMzmTiiO/deP4oHbxoTqSrXacPOgsDnT1fs5pX/bsTrHzzMzikKKfujhz5l655CAOav2M202YtZt/UAVR4PBwrDO2VWRKKTpo+KiDiPgkJxjOvOH8DUScPqXKn0pIx2ZKancMekYSHpv/jBKdx04cBwVLFWu3IPs3LTfh6YsySQtte/YM2mXQdrbJfx4PNLOVhUxubdvi0v7nxyAc+8/Q1Tn14Usg3GknX7mDx9noJFEWlSCgpFRJxHQaE4RkKcm5OzOh6/YOie9aQmx3PGkIzmqVQ9Pf76KnYEjQq+s2hb4HNt22U8+tpKPl+9N3D81focAP76vu+dRa/Xy6y31gKEXLcuN02fx22PfhbYh1FEpC6NXTBLRERaLv1ql6iTmhwfcpwQ7wbA9Ggfkj64dz0CzAjZsa/24G1PXjHvf7mdm/74SSBtzZY8/jlvE1+s8QWRa7cdYMrjC3hv8fZAGS9QUlbJfX9ZcvQlRURCaKRQRMR5FBRK1OneOYV7rx/Fk7efyZTLh9Klg2+66eUT+oSUO6lrO4Bat9CoXv20JXrtk80hx/OW7eKDJTt49t1vKCmr5JFXV1BUUsHrn25m3bYDNc6fPH0e//Xvu1ibPXmHeWP+Zrxeb51lRMS5XAoKRUQcJyz/sjXGPAxcBmQBQ6y1a2op4wZmAOfjG7iYbq19Lhz1k+hzUoYv4BvWt1MgrU+31JDN4Q8WlbFk3T5+etkQAP73mS/5zqk9OW90D9q2iae4tAJ3TAwJ8W7unLmI/QdLyUhrQ9/MVLK6tuXFCKx2ejz5h8pCjv8xbxPdagl6X/54A507JDGkd1qNvMdeW0luQSnlFR6u/Fa/ZqurSLQwxvQHngfSgDzgOmvtxqPKnAf8HhgCPGGtnRr2ivppSwoREecJ13DHXOBxYMExylwN9AX64esYlxtj/mOt3db81ROpKTUlgT/8+LTA8XN3TQjJb5N4ZOXTB24cQ2l5JR3bJQbSKio9bNx5kLEnd+HpuTWeg0TE0e8n7sgpqvOdw+c/WM/Dt55RI73K4xsh/Hhpdp1B4SP/WMHu/Yf56aVDAgG4iNRpFvCUtfYlY8w1wGxg4lFltgA3A5cDiURQrIJCERHHCcv0UWvtQmtt9nGKXQE8a631WGtz8QWS32/+2omcuDaJsSEBIcB5Y3py26VDGDWgM3OmTeSH3z0ZqHuPr8z0miN2LcWz73zDnH+vIzuniINF5SF5ZRVVvP35VrbvPRRIW7v1APmHynjw+aWs2ZpHZZWHopKKcFdbpMUzxnQGRgCv+JNeAUYYY9KDy1lrN1lrVwCVYa5iDRopFBFxnpb0YlRPYHvQ8Q6gR0MvkpaWcsIViZbNwNXO8LpwfDKvztvEjy4eTElZJU+/sSqQd9W3B9ClYxKPvrI8gjUMdaCwjMnT5/HwlDP5Yq1vkZqFq/eElNm+v5i1W/KYu2Arcxds5cbvDqJ929CFfIorvPzlvfV8uXYv7zzyPUrLK9mZUwRe6HvU4j4AxaUVIaOwwVrKvWxu0dDOaGhjPfUAdllrqwCstVXGmN3+9Nym/rKm6CM7dkyOivunNjqH2ukc0dBGiEw7W1JQ2CTy8orweBq/AEZ6eltycw8dv2Arp3ZGxuNTxgGELNIy+KSOnDWkC19+k1Oj/IM3jcHtjuGeZxaHrY5Hmzqj7lnfv35uMcP7HXkv86/vrq1R5tOlO1i/owCA3NxDTJ4+L5AX/A7n715cSmWVl+17D3HXVcMxPTuEXKel3cvmEg3tbIo2xsS4miTAiTYn2kcClBaX6e+oA0RDG0HtdJJoaCOceDsb2z+2pNVHdwC9go57AsebcirSKrlcLp68/UwevGkMv7xiGHGx7hqreY4Z2JnM9BS6dmzToGvfevFg7r9hdFNW95iWb9x/zPzqgBDghQ/W18h/+/OtbNp5kM27CgNTUDfsPAjAvGU72V9QAsDSdfuorPLU+T3TZn/Bc+9+0+D6i0RYNpDpX2ytetG1brTA/q+L/3dR38zUCNdERESaWksKCl8DfmiMifG/S3Ex8HqE6yTSbNokxpGZfuRJztA+aaQkHZk2ec15JqS8C+jSIQmAUSadP/zo1BrXbJ8Sz6gBnenVtWVOr/h0xe6Q49yCEuYu2MrvX/o6JP3Nz7bwq6cX8dJHG3j41RVs2nWQXz+3uMZ2GzkFJWzI9gWdOfklLPLvxViX4tIK/vb+esrKq5qgNSInzlqbA6wArvQnXQks979b36KkJMYyrH+6tqQQEXGgcG1JMQO4FOgK/McYk2etHWSMeQ+4z1q7FHgRGAtUL8P9G2vt1nDUT6QlSE1JYMbPz2TL7kLmr9hFcuKRH88ZPz+TWLeLj77KZu6CrYwb2i3w1B7g8rP7cMGpvWq7rG/VVC88PXcNyza0rH9n3jXrizrz8gpLAV/g9/sXfUHjx0uzSU6KZaTpTGanZKYd4/zC4nI27zxIn+6pLFq9l2+P6cG/F2/ns5W7SU2O55LxvZu2McdRWeWhqspLQrw7rN8rrcJPgOeNMfcB+cB1AMF9pDFmHPAq0A5wGWMmATdZaz8MVyW9+B5OiYiI84QlKLTWTgGm1JJ+QdDnKuCWcNRHpCXr3a0dvbuFbuNQPYJ44Wm9yOralqF9fPsHJifGcri0kkFZHeu8XozLBS645eJBzH77G5aur/nu4kiTztctb2CiVtWL2kydNKzW/JWb9pPVtS1PvrmazbsK6dOtHZt3F1JcVsmu3MMAvLNoW51B4YJVu+mbmUpGWjL7DhRz8HA5/WtZEKehHnl1BTa7IOQ9ShEAa+16fA9Fj04P7iMXAt3DWa/aaJRQRMSZWtL0URE5DndMDEP7HFnY5Ynbx/POI9+r13RRd0wMt148OHD8s0uHBD7fevFgrj63f9NWtpk9/OqKWtMff30Vf/z7cvYX+EYaN+8uBODdRdtYtTmv1nMOFZdTWFyO1+vlr++t5/45SwC4+5nFTH95WUjZvQeK+dv76/n5jAUh23Acj80uOGb+uu35vPiRrff1RMLNe2Lr04iISAvmuNVHRcRn9IDO5BeV1UifdcdZuFwu4mJjmDSxLyef1BGXy8U5I7sT63axesuBWqeZ/vEnpx1zumdLsvdA8XHLTJ4+j8enjGPWW2tZtz0fgEv9o4eVVV7+/cW2QNnsnCJ6dPa9//nUm6sDI44ffrWDH100iJz8Ytq2iScpofG/Uh/yb0fyy6tHNfoaIs3Lq/mjIiIOpaBQxKFuCRoVDBYfd+SdtvPG9AzJO2tYJmcNy+TOmYvYf7CUOyYN45FXV/DgTWMc+W/Bn89YGHL8r8+2BD6/Mf/I5/vnLOHOK4fj8Xp9L1b5xbl9ky2mzV5M9/QULji1J2mpifTr3vjpptWr0O7Yd4i2beI5UFhKH632KC2AVzGhiIhjKSgUkRruvGo432zLZ1BWx8A7cNVbQ1T79eQxrN6Sx+79h0NW/ezbPZVN/i0lqmV1bcu5o3wLvezef7j5G9AM/uQfyQtWXFpJ/iHfaOzO3CKeece3JUb1n9nu/YdJSYoLLJoD8MCcJQzM6sAVE/vV+j2VVV6+2XYgZHps9fU8Xi+fLt/FuCEZIcG9SLjonUIREWdSUCgiNXRKTWL8KUkhae2S4wGYfMFAxg3NAAhMqbzqW/1wx8Sw90AxPbv40m764yeBcyeMyOS0wV3p36M9//hkE5ed1Zu7Zy+u8/sT4t2tYtuIrzfk8nUtU20nT5/HbZcM4ak3V9fI25FTxI6cokBQ+MKHlk+X7wrkV3k8zHprbcg5Xq8Xl8vFyk37eemjDbz80Qa8wOypZxEXq+BQwkOvFIqIOJcWmhGReomPczNn2sRAQBisTWIcCfFuenVti8vlwuVy8d3Te3HPtSO59eLBnDHEd05aaiK3XjyYLh3acPN3BwKQlODm+2f3AXwjis/eeTZP3n5m+BrWTGoLCIM99+435BaUhASEABt3FFBUUhGS9tPHFvDvL7bx+qe+fRqr/3F++xOfU15R/+D5cGkFO3OK6l1eJISiQhERx9JIoYg0i0vH9zlm/umDMzh9sC9YLCuvYt6yXfxgQl/cMXU/q7r3+lE8+PzSkLSeXVLYsa/1BTqL1uwNmXZb7Z6Zn9dIKymrDHnHMTh9X35JYMQ2mMfrJSe/hNgYFx6vl2lBI7MP3jSGzh2SGj3K+NbCrVR5vIGFeY6nyuOhvMJzQgvxSMug2aMiIs6kHlpEIi4h3s1Dt55ea95jPxtHXGwMXbq0o7CgmAdvGsO9f/FtGTHrjrOIi40Jmapa7Zlfnc2f/r6cTbsO1shzktLySiZPn8e4IRmMObkz/5q/hZQ2cSTGuVlax96T9/5lCfGxMZRXerj2vP5MGHFk+7sl6/bRoW0CXTq2IcblCuyRGeythVsB6h0U/vW99Sxas1d7NLZyXg0Viog4loJCEWnRqt9lTPAvrJKWmgj4FrSpXmwlKSGWkrLKkPNi3THcc+3IwPE/5m3kwyXZJMa7+e3NY5n69KJwVL/Z/eEl3z6KC1fvYeHqPfU+r7zSA8CbC7YyYUR33pi/mW17Clm7LT+kXEMCueycIpITY+nYLjEkvXpEtLLKQ6xbby20Wl5waf1RERFHUlAoIq1KYnwsUycNI6tr20Dar28cTXZuETEuF4+/vqrW8y4d35uMtGTOHJqBy+Xi/64bhcfr5cu1+9h/sITzRvfgoaAVP6NFUUkFXq+Xf3+xvc4yXq+XxWv3MTCrA+1TEmrkezxeissquX+ObwR3zrSJ5BaU8PFX2Uw6px8ufK+jVVR6WLo+h/krl3PXVcObqUXSnDR9VETEmRQUikirc3JWx5DjTu2T6NTet1rqH350Kp07JNU4Jy7WzfhTugWOe3drB0Bf/x6Au3JrvpfYrk0chcUVNdKDdeuUzPhTuvHqfzc2rBEtyPtf7jhm/hvzt/DeYl/QOLBXh0D6XbMW8ZvJY7nlz/NDyucUlDBt1hcAnDEkIzDpsKLSQ3ZOEVt2O3tKr1Np8qiIiHMpKBSRFumHF51MhX+KY0N06dimUd+XmZ7C3deMoENKAjv3Hya9fRJt28Rx+1Eb3APcf8Nofv23rwC47/pRVHm8tQaFt10ymB5d2gYCpIa48LRexxy9a0rVq5rW5jd/+4ptew8FjtdtPzK9NLeglNVb8mqc8/sXjiwG5HYfGVqqqPSwbENuo+6rRJ5XUaGIiGMpKBSRFum0QV3D/p39urcHCIw6Avzuh2NJiHMTH+dmyuMLAOgVNHU1Ps5d67YQj/70DFJrmWpZ7fKz+4QEY2cP68aCVXuo8vj+5X3ZWX343riT+NFDn55Qm05UcEBYm6fnrqmRFjy6ep9/USCAX810xnuc0cur6aMiIg6loFBE5Bgy0pJrTb9j0jDa+LdYiIuNYfBJHVmz9QDTrh5B/x7tQ8rec+1I9uYVs3xjLpef3SdwzeCgsFP7JLp1SiY7p4j7bhgFELIoy8BeHUJG6UQiwaWoUETEkRQUiojU03dPz2LJun0ADAp6r9HlcvHLK4bVeV7fzFT6ZqYybmhGrfkXnZ7FuaO6M25IBvkllfTqdGQK7HN3TuBQcXlg1PGJN1aRnVNE727tWLIup8a1pl09gpc+suzMPdyoNorURbNHRUScS0GhiEg9XTq+d7335quPO68cTk5BSWABnLhYN32y0sjNPTJlMybGFTIN9WeXDQ18HmlymDl3DSNNgRcV0QAADHFJREFUOl/79yTs36M9543uyZz31nH9+YbnP7AAjD25C19+s6/J6i5RSFGhiIhjKSgUEYmQAb06MCBoNc+GGj2gM6P9+whOnj4vkD5uaAbjhmbg9XppkxjH8H6diHXHcPW5/XnxQ8ukc/pxx1OfAxDjcjHl8qH89+udgUVjxg3NYOGqY+95eObQDBYcp4w4j2aPiog4k3YRFhFxKJfLxegBnQPvJqYkxXHLxYPp0DaBhDg3AM/dNYGhfdK44TsDAudNvmAgc6ZN5Hc/HEvHdrUvlnPjBQMDnx++9fRay9x04UCuPa9/SFpW17Y8e8+3TqhdEhkaKBQRcS4FhSIiUeixKeOY+cuzAscd2ibwzK/O5qlfjA+kZaQlc4f/Xcnvn92nzmt1bJfIgJ5HFtfp2TkFgOTEOLoGLdQzoGd77rthdEiatB5erxcXGioUEXEiTR8VEXGASef0I61dYr3LV48UBot1x4SseAq+wHCOf4rqhBGZuFwuqqpq7jN451UjWL89n4y0NrRJjGOpzeGUvmm4XC5+e/NYMtLaaOVKJ9AtFBFxJAWFIiIOcN7oHs3+HYnx/i7DH1D++H8GERd7JIgMfj8yeJ/Jbp00MugE54/tSVZm49+BFRGRlktBoYiINMrYk7tEugoSRmcO7UZ6etuQ1XFFRMQZFBSKiIhEkDGmP/A8kAbkAddZazceVcYNzADOx7fmy3Rr7XPhrquIiDiTFpoRERGJrFnAU9ba/sBTwOxaylwN9AX6AacBDxhjssJWQxERcTQFhSIiIhFijOkMjABe8Se9AowwxqQfVfQK4FlrrcdamwvMBb4fvpqKiIiThW36aD2nxzwA3Ars9id9bq29LVx1FBERCbMewC5rbRWAtbbKGLPbn54bVK4nsD3oeIe/TIOkpaWcQFV90tPbnvA1WoNoaGc0tBHUTieJhjZCZNoZzncKq6fHvGSMuQbf9JiJtZR7wVo7NYz1EhERiQp5eUV4PI3fhj5aFpqJhnZGQxtB7XSSaGgjnHg7Y2JcjXoAGJbpow2YHiMiIhJNsoFM/0Iy1QvKdPOnB9sB9Ao67llLGRERkUYJ1zuFNabH4JsiWtvUl0nGmFXGmI+MMaeFqX4iIiJhZ63NAVYAV/qTrgSW+98bDPYa8ENjTIz/gerFwOvhq6mIiDhZS9uSYhbwO2tthTHmXOAtY8xAa21efS+g9yXqT+10jmhoI6idThINbWyAnwDPG2PuA/KB6wCMMe8B91lrlwIvAmOB6nfxf2Ot3RqJyoqIiPOEKygMTI/xv0Rf6/QYa+3eoM8fG2OygcHA/Pp+kd6XqB+10zmioY2gdjpJU7Sxse9MtETW2vX4Ar6j0y8I+lwF3BLOeomISPQIS1Borc0xxlRPj3mJOqbHGGMyrbW7/J+HAVmArefXuMH3D4UT1RTXaA3UTueIhjaC2ukkJ9rGoPPdJ1yZ6KA+soGioZ3R0EZQO50kGtoIJ9bOxvaPLq+38aNqDWGMGYBvS4oO+KfHWGtt8PQYY8zzwEigCigH7rfWvlfPrxgHLGiGqouISMt1JrAw0pVoBdRHiohElwb1j2ELCsMgARgN7MEXVIqIiHO5gQzgK6AswnVpDdRHiohEh0b1j04KCkVERERERKSBwrUlhYiIiIiIiLRACgpFRERERESimIJCERERERGRKKagUEREREREJIopKBQREREREYliCgpFRERERESimIJCERERERGRKBYb6Qq0JMaY/sDzQBqQB1xnrd0Y2Vo1nDFmG1Dq/w/gLmvth8aYU4HZQBKwDbjGWpvjP6fOvJbCGPMwcBmQBQyx1q7xp9d53xqbF0nHaOc2armv/rxWdW+NMWnAi0AfoBzYCPzYWpvb2La0wnZ6gdWAx1/8Wmvtav95FwEP4fsd/TVwo7W2+Hh5kWKMmQuchK8tRcDPrLUrnPazGc2cdE+c2EeqfzTbUP/opHY6pn+E1tNHaqQw1CzgKWttf+ApfD9ArdXl1tph/v8+NMbEAC8Bt/nb9xkwHeBYeS3MXGA8sP2o9GPdt8bmRVJd7YSj7isc+/614HvrBf5krTXW2iHAZmB6Y9vS2toZlH960P2s7vBSgGeBi6y1fYFDwNTj5UXY9dbaU6y1w4GHgTn+dKf9bEYzp90Tp/WR6h/VPzqinUH5TukfoZX0kQoK/YwxnYERwCv+pFeAEcaY9MjVqkmNBEqttQv9x7OAH9Qjr8Ww1i601mYHpx3rvjU2r7nbcTy1tfM4Wt29tdYesNZ+GpS0GOhF49vS2tp5LN8BlgY99ZsFXFGPvIix1h4MOkwFPE782YxWUXJPWt3vl2DqH+vU6u6r+sdjanX9I7SePlJB4RE9gF3W2ioA//93+9Nbo5eNMauMMU8bY9oDPQl6smat3Q/EGGM6HievpTvWfWtsXkt29H2FVn5v/U8xbwHepvFtaW3trPapMWaFMeYPxpgEf1pIW4AdHPl7eay8iDLGPGeM2QH8Drie6PvZdDIn3pNo6COj7WdQ/WPD81oEp/eP0Dr6SAWFznSmtfYUYDTgAp6McH2kaTj1vj6Bb469U9pTl6Pb2dNaOwrfVKiTgXsjVbGmYK292VrbE7gH3zsdIi2VU3+XRjOn3lP1jw7oH6F19JEKCo/IBjKNMW4A//+7+dNbleqpFdbaMuBp4Ax8T0wCw/LGmE6Ax1p74Dh5Ld2x7ltj81qkOu4rtOJ76180oB9whbXWQ+Pb0traGXw/C4HnqON+4nv6mV2PvBbBWvsiMAHYSZT8bEYBR92TKOoj1T+24vuq/tF5/SO07D5SQaGf9a3CtAK40p90JbDcWpsbuVo1nDEm2RiT6v/sAibha9fXQJIxZpy/6E+A1/yfj5XXoh3rvjU2L3y1r79j3FdopffWGPN7fO86XOzvyKHxbWlV7TTGdDDGJPk/xwKXc+R+fgCMNsb08x//BPhnPfIiwhiTYozpEXR8EXAAiIqfzWjgpHsSTX2k+kegld5X9Y/O6B+hdfWRLq/Xe6LXcAxjzAB8S7x2APLxLfFqI1urhjHG9AbeANz+/74Bplhr9xhjTse3QlEiR5Yk3uc/r868lsIYMwO4FOgK7AfyrLWDjnXfGpsXSbW1E7iIOu6r/5xWdW+NMYOANcAGoMSfvNVae0lj29Ka2gn8CV9dvUAcsAi43Vpb5D/ve/4ybmA5cIO19vDx8iLBGNMFeAtIBqrwdXZTrbXLnPazGc2cck+c2keqf1T/6JR24qD+0V+nVtNHKigUERERERGJYpo+KiIiIiIiEsUUFIqIiIiIiEQxBYUiIiIiIiJRTEGhiIiIiIhIFFNQKCIiIiIiEsUUFIqIiIiIiESx2EhXQETCxxiThW8foDhrbWWEqyMiItIiqH+UaKeRQhERERERkSimoFBERERERCSKubxeb6TrIBLVjDHdgCeA8UAR8Ki1doYx5gFgMFAFXABsBG601q70nzcQmAkMA3YBd1tr3/bnJQG/BS4H2gOrgXOBLvimx9wAPAi08X/f78LRVhERkfpS/ygSPhopFIkgY0wM8A6wEsgEzgFuN8Z821/ke8BrQEfg78BcY0ycMSbOf95HQGfgZ8DLxhjjP+9hYCRwuv/cOwFP0FePA4z/++7zd6AiIiItgvpHkfDSSKFIBBljxgKvWWt7BqXdDfQHtgPnW2tP9afH4Hvi+QN/0deAbtZajz//FcACvwEOA6dWPzUNunYWviehPay1O/1pS4A/W2tfba52ioiINIT6R5Hw0uqjIpHVC+hmjCkISnMDC/B1etnVidZajzFmJ9DNn5Rd3eH5bcf3NLUTkAhsPsb37g36XAykNLoFIiIiTU/9o0gYKSgUiaxsYKu1tt/RGf53JnoEHccA3YHd/qQexpiYoI6vJ7AB2A+UAn3wTbsRERFpbdQ/ioSRgkKRyFoCHDLG3AXMAMqBgUCSP3+kMeZS4G1gClAGLAZc+J5g3mmMeQQ4A7gIGO1/YjoH+LMx5lpgHzAGWBa+ZomIiJwQ9Y8iYaSFZkQiyFpbBXwX3wppW/E9xXwOSPUXeQu4AsgHrgUutdZWWGvL8XVy3/Gf8zRwnbV2vf+8qfhWVPsKOAD8Ef28i4hIK6H+USS8tNCMSAvlnx7T11p7TaTrIiIi0lKofxRpenoyIiIiIiIiEsUUFIqIiIiIiEQxTR8VERERERGJYhopFBERERERiWIKCkVERERERKKYgkIREREREZEopqBQREREREQkiikoFBERERERiWL/D1LcBaC1+4pdAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -255,100 +268,36 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 4, 6, 7, 12, 24, 17, 5, 10, 29, 14, 14, 51, 44, 41, 45, 35,\n", - " 39, 39, 4, 46, 8, 11, 23, 13, 17, 10, 4, 22, 7, 15, 15, 7,\n", - " 21, 5, 11, 28, 14, 43, 5, 4, 9, 5, 8, 11, 4, 6, 9, 5,\n", - " 4, 18, 8, 12, 4, 7, 22, 4, 27, 11, 7, 31, 5, 20, 4, 8]],\n", - " dtype=int32)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def generate_based_sequence(length_sentence):\n", " index = np.random.randint(0, len(data) - sequence_length - 1)\n", - " ids = sess.run(model.predicting_ids, feed_dict = {model.X:[data[index:index + sequence_length]]})[0]\n", - " ids = ids.tolist()\n", + " x = np.array([data[index:index + sequence_length]])\n", + " initial_state, ids = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: x})\n", + " ids = ids[0].tolist()\n", "\n", " while len(ids) < length_sentence:\n", - " new_ids = sess.run(model.predicting_ids, feed_dict = {model.X:[ids[-sequence_length:]]})[0]\n", - " new_ids = new_ids.tolist()\n", - " ids += new_ids\n", + " initial_state, ids_ = sess.run([model.predict_state,model.predicting_ids], \n", + " feed_dict = {model.X: [ids[-sequence_length:]],\n", + " model.encoder_state: initial_state})\n", + " ids.extend(ids_[0].tolist())\n", "\n", - " return ''.join([rev_dictionary[i] for i in ids])" + " return ' '.join([rev_dictionary[i] for i in ids])" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ar this worfort we have a king:\n", - "Better in the cannot swear in cor this worforth we again. I hear in them\n", - "Because it on the cause this worfort way fought a king.\n", - "Where in the can on the kings.\n", - "this worfort way for what in he\n", - "With cereman to know in the chanhis worforw worth a woman with\n", - "her citizen the mocked in hang.\n", - "\n", - "is worforw worth water woman\n", - "With her comminted the king condents worforw worth water\n", - "would make him the crown in the king.\n", - "\n", - "BUC worforwow worth\n", - "wate worth me hither can to give king.\n", - "\n", - "BUCKINGworforwoworw\n", - "worth water worth the city can give king.\n", - "\n", - "BUCKINGHorfowrow\n", - "wortworth war worth the city can give king.\n", - "\n", - "BUCKINGHAMrfowrow\n", - "worthward worthy the cright and king.\n", - "\n", - "KING HENRY BOLINGfoworw\n", - "wrown what to her thrick with can delive.\n", - "\n", - "KING HENRY BOEOSowworw\n", - "what wront that whom the prince.\n", - "His gave know me.\n", - "\n", - "HENRYwwwowrw\n", - "what wront that where him.\n", - "\n", - "DUKE VINCENTIO:\n", - "He knight hawwwwharw\n", - "what wront that where him.\n", - "\n", - "HENRY BOLINGBROKE:\n", - "He king wwwharwhat\n", - "wrong wather then which.\n", - "\n", - "HENRY BOLINGBROKE:\n", - "He kingEOS\n" + "be the way to toe. First Murderer: What is my offence? First Murderer: What is the news of this new world, with the field? Second Murderer: What is his name? Second Murderer: What is his name? Second Murderer: What is his name? Second Murderer: I warrant thee, he was a traitor and his throats are gone To help him from his government. First Murderer: the duke to be deposed? Gardener: Depress'd he is the chiefest duke of his lawful crown. He gave him in his mercy, He is not his, He cannot proceed and he shall not live His honours with his bridal-day, He cried 'The courage to his arms, He prays his doubled spirit Re-quicken'd his own soul and his son are fallen with him. First Murderer: king that Henry will him king. EXETER: He is the king that he had held his power, He was his policy to counterfeit, He cannot guess and his crown his sides, His father was, he hath borne his grave? He prays his father hath been in peace and his followers? He is his policy and his body, He cannot guess of his country. He that he did him, and his followers? He was his policy to counterfeit, His father and his father gave him the root Of his own person; he hath been in his face, And with his bridal-day, he wiped his doubled spirit Re-quicken'd his poor father should have been a man. Second Watchman: He is his name? and he hath hid his wrinkled front; And he had been in his bed? First Watchman: He was a poor man; with his great blood, He hath made his person, and his followers? Is he not in his bed? WARWICK: He was the god of his own bringings-forth, and he did bend his natural steeds, And rob his own and so took his body To choke him like a thousand-fold he EOS had been in his bed? First Watchman: He was a poor man; his looks and his followers? He gave him in his bed, and his followers? He gave him in the malmsey-butt and he of his leather bottle. His wonted his father cried in his devouring paws; And with his name? and he returns, Splitting his head and grinning to his own person; And heard his honours even: He cried in his bed, And his pond fish'd with his chin and murder's thoughts. He throws to hide his brother! He was his name? and he lives to him, And his apparent passage who, the duke of him; he wept, And his poor father did not live in his digressing son. DUKE OF YORK: He would he speak? EOS his head with panting. His chronicle thus writ: 'The man was noble, And he himself thou, and his lustful bed and himself, And with his loins his babe's, betrays to slander, His sting and his own soul and the king's, his appetite, To his surname he took his body To choke his glories! GEORGE: And his poor father did he had his father's EOS head with panting. Now did he walks, his doubled spirit Re-quicken'd his own soul and his followers? He gave him in his face, And with his devouring paws; and leaves himself, And he to his bed, and his followers? Now he hath been his welcomes Then, by the sudden, he did his appetite, And choke he were as long to his bed, And his with his devouring paws; And so he walks, 'What he is gone, and his pond A traitor steeped in his loins his appetite, He cried in his devouring paws; And he did beat his honours with him. First Conspirator: And he hath seized his honours with his eyes, He doth choke the subject did in his face, And with his loins he kiss'd his his devouring paws; And he did sleep his honours with his oak. He cried as he under ease his body and his father doubly install'd; And consequently, his leaves with his devouring paws; And he did courage in his bed? First Watchman: He hath he in his bed? First Watchman: He hath the duke that did his father gave him his shoulder-bone; And he steeds, His head in his devouring paws; And he did courage in his bed? First Watchman: He is his name? and he is his heir; And his poor father were his father in his hearts, And set his head to his teeth, he hath drunk, and all his body To choke him in his devouring paws; And he did all the rest did EOS His father were his father and his father hath been in his face, And with his devouring paws; and his virtues Did not, he did his bed, and his followers? Is he himself in his bed? First Watchman: He is his name? and he hath hid his wrinkled front; And he in his devouring paws; And by the same and drowsy courtesy, which he father hath been his son; He hath his heir; and his grandsire is his heir; And his poor father were his father in his hearts, and his followers? He prays his father hath been in his bed, And all his summer leaves his will: PRINCE: His wonted his father gave him in the oak. He cried like a swine he lies! Grim And thrice hath been his policy and his body, And then his doubled to his bed, he cried 'God save him!' He cried as his virtues He gave him in his face, And with his summer leaves his sire He gave him in his face, And with his summer leaves his spring, And he that did the duke that did his father gave him his visage now his friends in his oak. He cried with oak. O monstrous and his father's bed, And with his loins he kiss'd his summer leaves his grave? He cried aloud, 'Hold, friends! Oxford, on his neck, And with his devouring paws; and leaves his bed, And all his summer leaves his will: PRINCE: His wonted the duke were now in his face, And with\n" ] } ], diff --git a/generator/8.char-generator-lstm-bahdanau.ipynb b/generator/8.char-generator-lstm-bahdanau.ipynb index 9d258af..2ff4a16 100644 --- a/generator/8.char-generator-lstm-bahdanau.ipynb +++ b/generator/8.char-generator-lstm-bahdanau.ipynb @@ -51,20 +51,40 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "65" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(text_vocab)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "learning_rate = 0.01\n", - "batch_size = 128\n", + "batch_size = 32\n", "sequence_length = 64\n", "epoch = 3000\n", "num_layers = 2\n", - "size_layer = 512\n", + "size_layer = 256\n", "possible_batch_id = range(len(text) - sequence_length - 1)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -74,12 +94,9 @@ " ):\n", " def lstm_cell():\n", " return tf.nn.rnn_cell.LSTMCell(\n", - " size_layer, sequence_length, state_is_tuple = False\n", + " size_layer, sequence_length\n", " )\n", "\n", - " self.rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n", - " [lstm_cell() for _ in range(num_layers)], state_is_tuple = False\n", - " )\n", " self.X = tf.placeholder(tf.float32, (None, None, dimension))\n", " self.Y = tf.placeholder(tf.float32, (None, None, dimension))\n", " attention_mechanism = tf.contrib.seq2seq.BahdanauAttention(\n", @@ -87,8 +104,7 @@ " )\n", " self.rnn_cells = tf.contrib.seq2seq.AttentionWrapper(\n", " cell = tf.nn.rnn_cell.MultiRNNCell(\n", - " [lstm_cell() for _ in range(num_layers)],\n", - " state_is_tuple = False,\n", + " [lstm_cell() for _ in range(num_layers)]\n", " ),\n", " attention_mechanism = attention_mechanism,\n", " attention_layer_size = size_layer,\n", @@ -128,24 +144,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:From :43: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", + "WARNING:tensorflow:From :39: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "\n", "Future major versions of TensorFlow will allow gradients to flow\n", "into the labels input on backprop by default.\n", "\n", - "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n", + "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n", "\n" ] } @@ -159,14 +171,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "till\n" + "And\n" ] } ], @@ -178,18 +190,25 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def train_random_sequence():\n", " LOST, ACCURACY = [], []\n", " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_x = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", + " batch_y = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " for n in range(sequence_length):\n", + " id1 = [k + n for k in batch_id]\n", + " id2 = [k + n + 1 for k in batch_id]\n", + " batch_x[:,n,:] = onehot[id1, :]\n", + " batch_y[:,n,:] = onehot[id2, :]\n", + " last_state, _ = sess.run([model.last_state, model.optimizer], feed_dict = {model.X: batch_x,\n", + " model.Y: batch_y})\n", " for i in pbar:\n", " last_time = time.time()\n", - " model.initial_state = model.rnn_cells.zero_state(\n", - " dtype = tf.float32, batch_size = batch_size)\n", - " init_value = np.zeros((batch_size, num_layers * 2 * size_layer))\n", " batch_x = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", " batch_y = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", " batch_id = random.sample(possible_batch_id, batch_size)\n", @@ -198,27 +217,26 @@ " id2 = [k + n + 1 for k in batch_id]\n", " batch_x[:,n,:] = onehot[id1, :]\n", " batch_y[:,n,:] = onehot[id2, :]\n", - " last_state, _, loss = sess.run([model.last_state, model.optimizer, model.cost], \n", + " last_state, _, loss, accuracy = sess.run([model.last_state, model.optimizer, \n", + " model.cost, model.accuracy], \n", " feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", - " accuracy = sess.run(model.accuracy, feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", + " model.Y: batch_y,\n", + " model.initial_state: last_state})\n", " ACCURACY.append(accuracy); LOST.append(loss)\n", - " model.initial_state = last_state\n", " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", " return LOST, ACCURACY" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "epoch: 100%|██████████| 3000/3000 [50:47<00:00, 1.23s/it, accuracy=0.736, cost=0.983]\n" + "epoch: 100%|██████████| 3000/3000 [06:46<00:00, 7.06it/s, accuracy=0.133, cost=3.28] \n" ] } ], @@ -228,12 +246,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4gAAAFICAYAAAASx9BTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd8W/W9//GXJG87Thzb2ZOQfAkEEsIeYZVxGaVwOy7pr1Bu2lJKSxel83bQljaliwKhUAptKCW9l1IohQAtZYQkhJkFJN/sPezYjhPvIf3+0LHjIdmSLOnI0vv5eORh6fs95+jztWNLn/NdnkAggIiIiIiIiIjX7QBEREREREQkNShBFBEREREREUAJooiIiIiIiDiUIIqIiIiIiAigBFFEREREREQcShBFREREREQEUIIoIiIiIiIiDiWIIiIiIiIiAihBFBEREREREYcSRBEREREREQHSO0HMAiY5X0VEJH3p772IiEicpPOb6URgEzAH2OVyLCIikjjjgFeBo4HNLscyGOQCpwB7gXaXYxERkcTyAaOBN4HmSE5I5wRxtPP1VVejEBGRZBmNEsRInILeG0VEMs0cYGkkB6ZzgrgXoKamHr8/EPNFSkuLqKqqi1tQqSoT2pkJbQS1M51kQhth4O30ej2UlBSC83df+hWX90fIjP+jmdBGUDvTSSa0EdTOSMXyHpnOCWI7gN8fGPAb4EDPHywyoZ2Z0EZQO9NJJrQR4tZODZeMTNzeHzuuk+4yoY2gdqaTTGgjqJ1Rivg9Mp0XqREREREREZEoKEEUERERERERQAmiiIiIiIiIOJI2B9EYcwXwI8Dj/LvNWvs3Y8w0YCFQClQB11lrNzrnhK0TERERERGR+EpKD6IxxgP8CbjWWjsLuBZYaIzxAvcBC6y104AFwP1dTu2rTkREREREROIomUNM/cBQ5/EwgkutlgGzgUVO+SJgtjGm3BgzIlxd8kIWERERERHJHEkZYmqtDRhjPgb83RhTDwwBLgPGA7utte3Oce3GmD1OuaePuspIX7u0tGjA8ZeXDxnwNQaDTGhnJrQR1M50kglthMxpp4iISKpLSoJojMkCvgV8yFq7zBhzFvB/BIeaJlRVVd2A9g4pLx9CZeXhOEaUmjKhnZnQRlA700kmtBEG3k6v1xOXm4EiIiKSvCGms4Ax1tplAM7XeqAJGGuM8QE4X8cAO51/4epctXTNXn74xzfdDkNERERERAa5VZsO8K+3drJyQyXfeWAF7X6/q/EkK0HcBYwzxhgAY8x0YCSwEVgFzHWOmwustNZWWmsrwtUlKeawHlq8jm370v+uvoiIiIiIdOf3B2hoagNgzeYDNDS1dqvfWVHHv97aSSAQYNXGA/gDfY9mvOuva1j0wkb+8Ox69lY18Jk7XuYv/3Zv44akJIjW2n3A54C/GmNWA38B5llrq4EbgZuNMRuAm53nHfqqExERERERSaq/vLiRL9y5hAO1jdz52Bq+++AbLHphIwEnEfzBH4LP//jseu56fA3PvLYdCCaWL6/aze7KOubNf5FNu2q7XTfQJZH855s7efyVzclrVBdJ2wfRWvtn4M8hytcDp4U5J2ydiIiIiIhILDbsPMiv/ncV8288g/mPvMN/feBopowZSkFeFlm+vvvQ3nYGNO6tagCg5nAz/3prJ8WF2Vx6+kQ68rxX1+wF4IklW7j8jIn8fNFK7M6D5GQHr//Q4nUcM7Gk87o9OxqfeW07N35kVjyaG5WkJYgiIiIiIiLJ9NTSrdQ1tfLxC6d1K3/+jR20tPl5c30FFQcbefh5S21dC7OnlfOF/zwegK17D7HnQD1nzhjF469s4ewTRrN60wFqDjcD8LclW7pd8/FXtrCxR69ghydf3UrJkFwAsn1eWlr97KtuYF91Q+cxDc1tvc4byGKbsVKCOACBQACPx+N2GCIiIiIi0sWytXt5Y10Fa7dUAfDxC6fx0ju7+NM/N/DA188jN8cHQF1Da7ev72w4stzJjxa+BYAZP4zFK7bzlq2goqaxs/5gXXOv112zuSpkPItf284Fs8cCUN/UOxEMp6W1PeJj4yVZi9SkpeTn8yIiIiIig1dLa3tn0haNX/xlJZ/75Ssh6w41tPQqe/CZdb1e59EXggu/1DW0srOiDoB/LN8GQHuPnrqu8wFfWrkboFtyCFBb1/t1w/EHArzw9q6Ij+/Q2BJ5Mhkv6kEcgEAgAOpBFBERERGJyCP/3MDStXv54adOZVx5+D1sD9W3kJfjIyc72NP3/rYaAJas3kNdYyuf/OAMqg81sWrTAR755wYA5l44lfrGVp5atq3X9d7ZUNmZBC5esYPdlfVhX/vAwUbuenxN5/NnX98RdTvjpam5PekJmxLEAehnxVoREREREelib3UwMWt05tu1tftDLgrz5buXMmVsMd+59uRu5X98dj0An/zgDL527/JudYteCL81xD1/W9v5eMnqPX3G+PX7XuuzPpnKS/KpqQ6fzCaChpgOgBJEEREREZEj/IEATX0Ni3Q+P3vwsL+mgRt+/jKvvbcv5KGbdx+ird3P4RBDSAei2YV5fbEYObyg3xVVE0EJ4gAElCGKiIiIiHR67KVN3PSrJWGTsD3O1hB4YJczD/CJJVs6VwbtaeFz6/nSXUt7lW/ZHXq10HTidWkmmxLEAVB6KCIiIiJyxPJ3g72Bm3bX8rSzAExtXTPNre3U1jV3Di2FI9s6HKht4mv3LmPLnkPMm/8iC59b33nMsrWhexe/9KuXE9OABPJFmfH5vO6kapqDGAOPJzi8VD2IIiIiIpJutu87TGNzG+NGFFHf1MrIkoJu9bsP1OP3Bxg/ovciMx0p0C//sgqAoYU5/OHZ9b2Oq29s5Q+Lj5QHAvDjh4PbSryyqu85gvE2siSf/T1WKE2EB75+PvPmv9jvcYV5WdQ3tZGb406CqB7EGHic//rKD0VEREQk3dz2xze5Y9FK/ueBFXzr/hX8bckWtu491Fn/3d+/zvcfeqPz+YadB2lr9wef9Fjh/4/P9U4OAX7z1zUhy90wurRwQOf/96XH9Cq75ZpZIY+943Nn8J1rT+rcEzGUay8xAOQ6K7gmm3oQY+DxAAEliCIiIiKSPpat3ctb6ys6nx9yNo9/evk2nl6+jYe+eUG34x9+3jLr6FLufGwN48oL+cG8U+k5iHIwfF5etelA1OccPW4om3YF50HOmTmGDbsOUpSfzZLVe2hsbue4ScNDnlc2NJ+yofmUl+TT1h5gX1U9G3bVUpCbRUNzG+fNGsNRo4sBOOO4UbE3agCUIMag48ZIQLMQRURERGSQqTzYyPDi3F5z3B58Zl1U13l55W5edjaR31VZzzPLt1FbH98VR+PpGx8/kZ89ujIu1xpVUtCZIAJ86vJjAbh6zlE0tvReoOeqOZO7PS8uyOH6S4/h2de3s2FXLZPHFPPe1mpKh+ZRNiyf3916nisrmIISxBgFuxAHwx0REREZXIwx04CFQClQBVxnrd3Y45iHgRO6FJ0AXGWtfSppgYpISqo51MR726rD9mBV1TbxDWefv44ewZbW9oi6PdZsriLbF36hlSde3Rp1vPHiDPDr01FjikOWn37sSFa8vx8Izv8bUZLP/7vIsHJjJc+8th2Ay8+YyOGGFo4/qpQ311fwobMns3Tt3l7Xysn2kdNjaOiHzz2Ky06fGPK1Lzl1ArOOLsPuOBhMEIvzAFxLDkEJYkw6FiDSIjUiIpIA9wELrLWPGGM+AdwPdBvXZa29ruOxMWYm8CLwfFKjFBFXBQLBzgpvj5Uxv7FgKXsP1PPFD5/AiJJ8hhRkU9fYyujSQrbuPcSPFr7V61qf+9UrEXV83PnYagBKi/OoOtQUl3bEy4PfvICXV+3m4eds2GO69phefsbEzuTvhiuP60wQf/rZM/B4oDAvmzWbg0NPrzxrElfNOarz3JPMiKhiu/yMSWHrvB4Po0sLGTW8gPJh+Rw7qSSqayeCEsQYeDxapEZEROLPGDMCmA1c5BQtAu4xxpRbayvDnPYp4M/W2tCbiIlIWnr0hY38++1dveYF7j1QD8BdjwcXgSkuyOZQQyu3XjOrVw/fG+v2s23v4ag/06ZacvjFjwQHVJw3a2zIBDE7y8vw4jy8Xg93f3kOB+taGFNawKyjyzjc2Nrt2KL87M7HJ5sRPLVsGyeHSQi/9YnZDC3MiUsbPB4Px00O3eubbEoQY6EeRBERSYzxwG5rbTuAtbbdGLPHKe+VIBpjcoCPAxcmNUoRcd2/394FwMoNlRw7eTiBQIDaut7z/zoWmvm5s+1EV/f9/b3EBhmDuRdOpaKmkfEjihhWlMv2fYf6Hbpqxg/rfHzdf5heSeJvbzm383FhXjaFecEkcMrYoX1ed9yIol4JeFdTxw0LWwcwc0opQ4ty+zwmFSlBjEHnEFN3wxAREbkK2GGt7f3Jrx+lpb33L4tFefmQuFwnlWVCG0HtHCwCgQBPvLy58/mStXtZ8OS7+P2p/ck0O8tLa5u/W9ntnzuT7/x2ebeyj196bK9zQyWIF54ygTknjsVuq2bCuCPDMsuH996yYuSI0HMPQ4nn/48f33R2XK6T7P+zShBjoH0QRUQkQXYCY40xPqf30AeMccpDmQc8FMsLVVXVDfgDZXn5ECorDw/oGqkuE9oIamcqO9TQQlF+Nu9vq+auv67hlv+axR+ePtLzV1ffkvLJIUBJUS4VB49sRv/pK6YzqjiX0uJcqg41k5Pt5ZgJJX3+fHJzfDS3tHP1nMl84vLjqD3YwPjhY7udU1fXe7R9pD/z4yYPT7n/HwP9P+v1eqK+IagEMQYeDTEVEZEEsNZWGGNWAXOBR5yvK0PNPzTGjAPmOMeISBqqrWvmK/cs48qzJvHUsm0AvbZp2LznUIgzU097jyT2zBmjAbht3mks+vcG/uuCqd3m/4Vy27xTef71HVx+xqReK4V2OP6o2Obx/e7W8/B6wq/QmkncWz81DSg/FBGRBLgRuNkYswG42XmOMWaxMebkLsd9EviHtbbGhRhFZIB+9ud3+MwdL7H7QD0/+dPbNDa3UVXbxKur97C/uoHfPvku728P/nqv2hj9Ru7J9t1Pntyr7NTpwcVdxpQV4u/ywXnquCNz/wrysvjU5cf2mxyOLMlnxLB8rr3E9Fq5tauCvCPX+f71p/C963vHFUqWz9vndTOJehBjcGQVU2WIIiISX9ba9cBpIcov6/H89qQFJSJxZ3ceBODJV7ewaXcta7dU8eLbu9jQZfP1N9dXAHAwxLDJVDGiJJ+KmkYmjhrCfbecy42/fIXzThzL3A8cTVt7gPe31XDNB47mwWfWAcGVP8ePiG7I409uOJ3igr4TyFAmjhrc803dogQxBh29z/6+DxMRERER6dOQguA2Cff9/T1yc0IPm+xYiTQVfeTcKZx8TLCnMCfbx51fPJvCvCx8Xi/ZWXDXl+YAdM6THFFSQF5OdCnIqOEF8Q1a+pSUBNEYMwl4skvRMKDYWjvcGDMNWAiUAlXAddbajc55Yevc5DkyCdHdQEREREQkJQQCAZa/u4/Tjh1Jls/L3qp68nKyKBnS9zYHpcVH6ptb2hMdZp/OmTmGJav3dCubMLKIK86YxL1PvttZ9oX/PJ4lq/ewZnMVpUPzuh1fXBB6X8CjRhezenMVOVma4ZbqkpIgWmu3AbM6nhtj7uzy2vcBC6y1jxhjPgHcD1wQQZ1rlB+KiIiISFdv20oefGYdlQcbuWrOUXzngdcBeOibF9DU0sY/lm3juMnDGV6cR1uX7R4ef2WLWyH38omLp3UmiPm5Phqb27no5PGcfMwI7vjcGWzbe5jxI4oYOTy4yfzOirqIh3F+9kPHsa+6gfxcDWBMdUn/CTmb+v4/4BJjzAhgNnCRU70IuMcYU05wO/qQdaFWc0umjumrfmWIIiIiIgLU1gc3qd+w8yB/+Xf3AW8Ln7O8/v5+nn19hxuhhTT/s6fzl39vYtWmA1x51iROnFpOli/Yu3furDHMmFzKvU+u5SRTDkDZ0HzKhuZ3nu/1eqKa45eXk8WkUZHvRyjucSOFvxLYba19xxhzkvO4HcDZ82kPMJ5gHhauLuIEMR4bAffcnLLjl6ekpHDQb7baVTq1JZxMaCOonekkE9oImdNOEUlPNYeb2bQ7uLjM+h0HWb/jYGfd/720idff35/UeMaWFbL7QH2fx4woKeDz/zmDtvYAuV22jHjom0cG6z34DdcH7okL3EgQY97UNxYD3Qg41OaUHT2HVdX15KXJMOrBuHFstDKhjaB2ppNMaCO4swmwiEg8tLa1s3FXLb998l3qm9pCHvNcEnoNv/zRmdz52OrO51ecOYnpk0ooyM1i695D/PSRdwD4wOxx/PudXZ3H+bxefGnyWVbiJ6kJojFmLHAucK1TtBMYa4zxOT2EPmCMU+7po85VHUNMtc2FiIiISGbZV91AQV4Wzyzfzr/ecu9j6fknjuWllbsZWpTD5NHdR2EUFWR3LhYzddwwvnf9ydQ3tnHc5OGcfEx5tx7OdDViWH7/B0lIye5B/CTwjLW2CsBaW2GMWQXMBR5xvq7smGPYV52bjuyD6HIgIiIiIpIUNYeb+ffbu1i8YrvboQBw7SWGc2aOoaQ4l2xnZdAPzB7HmSeOZXJ5Ybdju879MxNKMBNKkhprsv3406cxtCj0aqrSv2QniNcDX+xRdiOw0BjzPaAGuC7COtccWcVUGaKIiIhIOgoEAjz20maGFGQzadQQFr++g/e2Vic1hpNNOU0t7VTWNrG/uqFXfddFYu7+8hzyc7MYOaI4I6Yn9GVMWWH/B0lYSU0QrbXTQpStB04Lc3zYOjd5UA+iiIiISLqqrW+h+lATz73h7qqjN119PBBMVn/92GomjyrmH8u3hTy2MC87iZFJOtNGJDHo7EFEGaKIiIhIuvnK3UuT9lpej4eigmwOOdtkhOLxePjqx4JbiodLEEXiRQliDDQHUURERCQ9HG5oobmlnerDzTQ0tTFrallSX//aS6YxbfwwvvPA693Kp4wNvWfgFWdOpKQoNxmhSYZSghiDI3MQ3Y1DRERERAbma/cup7XN3/m86z6AiTTr6DKuv+yYztVGj5tUwsRRxax4fx/Vh5o7ewx7+s9zpiQlPslcShAHQIvUiIiIiAw+y9/di9fj4dRjR3ZLDgHmzX8xoa993SWGh5+3+HyezuQQ4JZrTgTg4lPGU1nbSH6uPqaLO/Q/LwbejiGmLschIiIiItH7/dPrANi+P/mrfRblO4vJhPkgWVyYQ3GhtmgQ93jdDmBQ0jYXIiIiIoPe82/Ed6P7z155XLfnQ4tyuOW/ZjGsKIeLTxnPNRcczdRxQwG48ORxcX1tkXhRD2IMtM2FiIiIyOCyeXctZWVFPPj0+3G/9twPTOUDJ43D6/Xw15c3U3Woic9ccSzHTCyhZEguv/rC2d2OT9Y8R5FYKEGMgVc9iCIiIiKDxsqNldz9+Fo+UVnPsnf3xf36F50yvvPxz286M+7XF0kmDTGNgba5EBERERkcWtv87DlQD8Ajz62P+vwfzjs13iGJpDT1IMZCPYgiIiIig8Jnf/HygM4fW17I9Zcew6jhBby6ek9CeiBFUokSxBg4+aFWMRURERFJUcvW7mXxiu0DusYdnzsDj8fDOTPHAHDUmGI+dPZk9lTVs23fYfJyssjJ1oA8SS9KEGOgIaYiIiIiqSteexmWDc3v9jzL56VsWD5lw/I5YUpZXF5DJNXolkcMPBpiKiIiIpJ2br1mVufjAm1ULxlKCWIMOhNEd8MQEREREWDr3kM8tWwrAA8/b2O+zsjhBZ2PP3r+lAHHJTIY6dZIDI4MMVWKKCIi8WWMmQYsBEqBKuA6a+3GEMd9DPguwanxAeBCa+3+ZMYqkip+tPAtAJ58dWvU595w5bH87qng3ojDi/P48kdP4OixwyjI08dkyUzqQYxBxyI1fuWHIiISf/cBC6y104AFwP09DzDGnAz8ALjIWjsDOBuoTWaQIung29eexOnHjupWdsKUMiWHktGUIMbAozGmIiKSAMaYEcBsYJFTtAiYbYwp73HoV4BfWGv3AVhra621TcmLVGTwG1aUw9Fjh7odhkjK0e2RGHi1SI2IiCTGeGC3tbYdwFrbbozZ45RXdjnuWGCrMWYJUAT8DbjdWhvxG1NpaVFcAi4vHxKX66SyTGgjDN523v/EmpjO+8lNZ/dq82D9HvSULu3oj9qZGEoQB0BDTEVExCU+4ATgIiAHeA7YATwc6QWqqurwD/CNrLx8CJWVhwd0jVSXCW2EwdXOfdUNfOeBFdz+mdMZWZLP00ujn3cI0NzY0tnmUcMLOGpM8aD5HvRlMP0sB0LtjIzX64n6hqASxBh0DjHVGFMREYmvncBYY4zP6T30AWOc8q52AH+11jYDzcaYvwOnEkWCKDJYvfbuPgIBeOP9/RQX5sR8ncIu8wx/csPp8QhNJC1oDmIMjuyD6G4cIiKSXqy1FcAqYK5TNBdYaa2t7HHoo8DFxhiPMSYb+ACwOnmRirgn4Nyg31NVz5LVe2K6xrmzxpDl08dgkVD0mxGDI6uYKkMUEZG4uxG42RizAbjZeY4xZrGzeinAX4AK4H2CCeV7wIMuxCqSVI3NbTy9fDsAb6yrYNu+yIbeTRzVfQ7X7Gk9130SkQ5JG2JqjMkDfg1cCDQBr1lrb+hrv6dI94JKtiNDTEVEROLLWrseOC1E+WVdHvuBrzr/RDLGX/4d+cfA82aN4eVVwR7GD8wex0OL1zFpdDHfuXY2Pq/6SETCSeZvxx0EE8Np1trjCW7uC33v99TvXlBu6EgQ1YMoIiIikjw1dc0RH9t1DaaOe/slQ3KVHIr0Iyk9iMaYIuA6YFzHEtzW2v1d9nu6yDl0EXCPs9+TJ1xdiLkYSaU5iCIiIiLJN7Qg8kVpuq7SO35EEXMvnMrlc6bQ0tiSiNBE0kayhphOIThE9PvGmPOBOuB/gEbC7/fk6aMu4gQxHvs89dx7JCcn+G0bMiQvrfZfSae2hJMJbQS1M51kQhshc9opIgOz7N19fdZf84GptLf7eezlzQwpzO5Wd9HJ4xlalEulEkSRPiUrQfQBRxFcie1WY8xpwD+Ajyb6hQe6z1OovUfaWtsBqK1tTJv9VzJhL5lMaCOonekkE9oI7uzxJCKDR0NTK00t7by/rabfYy8+ZTyBQIDiwhxOnT6CZ1fsALR+hEg0kpUg7gDaCA4TxVr7ujHmAMEexHD7PXn6qEsJGmIqIiIiklhfuPPViI67+JTxQDAZPOv40QB8/urjefSFDYwuLUhYfCLpJimzdK21B4CXcOYTOquTjgA2EGa/pyj2gkq6zjmIKEMUERERcdOxk0qA0DfuTzLl/PLzZ2nPQ5EoJPO35Ubg28aYtQT3b7rWWnuQMPs9dTknXJ1rvE6GqB5EERERkcSpqGno95gTppQBENAHM5G4SNo+iNbaLcB5IcpD7vfUX52rOlcx1R8iERERkXhqbWtnX3Ujo4YX8M37V/R7/OnHjmT52r2dQ0xFZGCSliCmk46JzkoPRUREROLrocXref39/Xz+6uMjOr64MIcfzDs1wVGJZA4NyI6BV/sgioiIiCTEpl0HAfj32ymzLqFIRlGCOAAaYioiIiISb8E78et3HHQ5DpHMpAQxBh4tUiMiIiISd23tfqoONbkdhkhGU4IYA48WqRERERGJu8df2ex2CCIZTwliDJz8UD2IIiIiInEQCAT49u9W8Pwb/c87PGfmaG7+cGQL2IhI9LSKaQy0iqmIiIhI/Ow+UM++6v73PASYOaWME6eWc8+Xz+kc1SUi8aMEMQYaYioiIiISP35//5+ppo0fhs/rYebUMgAK8vQxViQR9JsVAw9apEZERERkoPZW1TNqeEHn6KxwSotz+frcE/F61WUokmhKEGPR0YOoQaYiIiIiMVm3vYafL1rJJ//DUFHT2Oexl50xScmhSJIoQYyBt3OIqbtxiIiIiAxWlQeDSeHC52y/x/qUHIokjVYxjUnHEFNliCIiIiKx6C/pm3PC6M7HXq1GI5I0ShBjoB5EERERkYHJzur7Y+i1l5jOx159YhVJGv26xaBzmwtliCIiIiIx6W9hmiyfl2MnlQBQWpyXjJBEBM1BjI16EEVEREQS7qsfm8Wm3bVMGz/M7VBEMoZ6EGPg7ZiD6HIcIiIiIuno5g8fD4DX61FyKJJk6kGMRWcPolJEERGJL2PMNGAhUApUAddZazf2OOYHwE3AHqdombX288mMUyRRJo8ewolTy90OQyRjKUGMhZMX+pUfiohI/N0HLLDWPmKM+QRwP3BBiOMettZ+LbmhicTH27aSPz0fenuL/uYmikhiaYjpgChDFBGR+DHGjABmA4ucokXAbGOMulMkrSx4Yi11ja0h61pa/UmORkS6Ug/iAGiEqYiIxNl4YLe1th3AWttujNnjlFf2OPYaY8zFwD7g+9ba16J5odLSonjES3n5kLhcJ5VlQhshddo5fGheQmNJlXYmUia0EdTORFGCOAB+ZYgiIuKO+4DbrbWtxpiLgL8bY6Zba6sivUBVVR3+Ac6VKC8fQmXl4QFdI9VlQhshtdqZm+VNWCyp1M5EyYQ2gtoZKa/XE/UNQQ0xHQjlhyIiEl87gbHGGB+A83WMU97JWrvPWtvqPP6XUz8jybGKxORwQ4vbIYhIH5LWg2iM2QY0Of8AvmGtfd4YczrBCfj5wDbgE9baCuecsHWpQB2IIiIST9baCmPMKmAu8IjzdaW1ttvwUmPMWGvtbufxLGASEHrFD5EUUlvfwlfuXup2GCLSh2T3IH7EWjvL+fe8McZL8A3w89baacASYD5AX3WpQkNMRUQkAW4EbjbGbABudp5jjFlsjDnZOeYnxph3jTGrgQeAa621+9wJVyRytXXN/R5zxoxRSYhERMJxew7iSUCTtbbjVtJ9BHsK5/VT56qAxpaKiEiCWGvXA6eFKL+sy+NPJjUokTjpbwuLh74ZakcXEUmmZPcg/tkYs8YYc68xZhgwAdjeUWmtPQB4jTHD+6lLCepBFBEREYmPsqF5bocgIiS3B3GOtXanMSYXuBO4B3gi0S8aj2W8ey4tm59N/xN0AAAgAElEQVSfA0BeXnZaLa+bTm0JJxPaCGpnOsmENkLmtFMkU9kdNTz4zDomjS4Oe8z8z56RxIhEJJykJYjW2p3O12ZjzL3AU8BvgIkdxxhjygC/tbbaGLMjXF00rzvQZbxDLS3b2BhcfauxoTVtltfNhKWCM6GNoHamk0xoI7izhLeIJNf/vbSJA7VNHKhtCnuM19v38FMRSY6kDDE1xhQaY4Y6jz3ANcAq4G0g3xhztnPojcBjzuO+6lKCX3MRRURERPrl7WfuoYikjmT1II4EHnf2c/IB7wM3WWv9xphrgfuNMXk4W1kA9FWXKjQFUURERKR/m/cccjsEEYlQUhJEa+0W4MQwdcuB46OtSwnKEEVERET6tL+mwe0QRCQKyV7FNK0MYGqjiIiISEZobmkPW6eBpyKpx+19EAeljrwwoB5EERERkT719XHJ6/Vw4tQyRpQUJC8gEemTEsQBUHooIiIiMjA3XZ26s4lEMpESxAFQD6KIiPRkjHkCWAg8Y61tdTseETf5AwFu++ObbochIlHQHMQBUH4oIiIhvAp8D9hnjPmtMeZMtwMSccumXbVuhyAiUVKCOABKEEVEpCdr7a+stbOBc4CDwCJjzEZjzPeMMVNcDk8kqVrb/G6HICJRUoI4AAHNQhQRkTCste9Za79FcA/fBuD7wDvGmBeMMTPdjU4kOR751wa3QxCRKGkO4gB09CBu2l1L+bB8hhbmuBuQiIikBGOMIZgYfhxoAf4EXAFUAjcBTwKTXQtQJEn2V/feA/G8WWN4edUeF6IRkUgoQYyFkxgGAgEefOZ9lq3dx/DiXH5x01nuxiUiIq4zxrwFTAL+F/i4tfb1Hof8yhhzc9IDE0mitnY/C/62NmRd5cHGJEcjItFQgjgAb6yr6HxcfajZxUhERCSFzAeesta2hDvAWqveQ0lre6saWL25KmRdu19TdERSmeYgioiIxNchgj2InUzQRe6EI5J8oYaWdtDCNSKpTQmiiIhIfC0ADvcoO+yUi2SEe598N2zdp684lnNmjgbg0tMnJCskEYmQhpiKiIjE1whr7d4eZXuBUW4EI5JqRg4v4PpLp3P9pdPdDkVEQlAPooiISHxtMcZc0KPsPGCrC7GIiIhERT2IcTJhZJHbIYiISGr4AfA3Y8yDwGZgCvDfzj8REZGUph7EeNGCXCIiAlhr/w5cDBQClztfL3HKRTJadpY+eoqkOvUgxiAA+Lyebss0a8VmERHpYK19A3jD7ThEUsn1lx7D9IklbochIv1QghijngliQF2IIiLiMMbMAuYAZYCno9xa+70Izp0GLARKgSrgOmvtxjDHGmAlcK+19mtxCF1kwKoPNYUsnzF5OMOL85IcjYhES/38MfJ4Pd2eB5QfiogIYIy5AVgGXAB8AzgeuAU4OsJL3AcssNZOI7g1xv1hXsfn1D050JhF4un/XtoUslyflUQGByWIMfJ5eiaI+qsnIiIAfB34D2vt1UCj8/UjQGt/JxpjRgCzgUVO0SJgtjGmPMTh3wSeBjbEJWqROHljXUXIco22EhkcIk4QjTHnG2MmO49HG2MWGmP+YIzJyH2dvD16EDUHUUREHCOsta86j/3GGK+19lnggxGcOx7Yba1tB3C+7nHKOxljZgKXAL+OX9giA2d31ISv1GclkUEhmjmI9xJ8MwL4pfO1EfgdcGU8gxoMuuaHpcV56kEUEZEOu4wxk6y12wj27n3IGHMAaInHxY0x2QTfe//bWtsenIYYvdLS+GzPVF4+JC7XSWWZ0EYYeDvfWrefnz26Mmz95AnDyct1f/mLTPh5ZkIbQe1MlGh+S8daa3cYY7IIJooTCb7Z7UlIZINIls+DXwmiiIgE3QFMB7YBPwT+CuQAX4zg3J3AWGOMz0n+fMAYp7zDaIJ7Ky52ksNhgMcYU2ytvSHSIKuq6vAPcPhLefkQKisPD+gaqS4T2gjxaedtv18Rtu6hb17A4UONuP2dzISfZya0EdTOSHm9nqhvCEaTIB4yxowEZgDvW2vrjDE5QHY0L2iM+T7BTYSPt9a+a4w5neAk+3yCb6afsNZWOMeGrXNVj2Rwf02jS4GIiEgqMcZ4gCXADgBr7bPGmBIgx1pb19/51toKY8wqYC7wiPN1pbW2sssxOwiujtrxmj8AirSKqYiIxEM0i9TcDbwJ/JngqmoAZwHrI72AMWY2cDqw3XnuJfgG+HlntbYlwPz+6lJCj0VqANra/S4EIiIiqcJaGwDWAv4uZS2RJIdd3AjcbIzZANzsPMcYs9gYc3I84xUREekp4h5Ea+3PjDFPAO3W2s1O8W7g05Gcb4zJJZhYzgVedopPApqstUud5/cR7Cmc109dSmpt85Pl08KwIiIZbiUwjShuoHZlrV0PnBai/LIwx/8gltcREREJJaqZwtbazqW0jTHnA35r7SsRnv5D4BFr7bYuE+on4PQmOtc/YIzxGmOG91Vnra2ONOZ4TMLvOTE0Lz+n1yqmABv2HObCUycM+PXckgkTfTOhjaB2ppNMaCOkXTtfBp4zxvyR4NzBznkJ1tqHXIpJJKGaW9rdDkFE4iTiBNEY8wrwbWvtMmPMN4CvAm3GmAXW2p/0c+4ZwMkE92xKqoFOwg81MbSpsQW/P8DEkUMYUpCN1+thzeYqDlTXD9rJspkw0TcT2ghqZzrJhDaCOxPwE+wsYCtwbo/yAKAEUdLO3qp6nlq2ze0wRCROoulBnAF0LE/1GeB84DCwDOgzQST4Jjkd2Or0Ho4DngfuIrgaKgDGmDKCvZLVxpgd4eqiiDmhvv/fpwCweU8tazZXUVqc53JEIiLiNmvt+W7HIJIsbe1+vvPA62HrfzjvVPZWNyQxIhEZqGgSRC8QMMZMATzW2vcBnNXZ+mStnU+XBWaMMduAK4D3gRuMMWc7cw1vBB5zDnsbyA9Tl1Jys32AFqkREZHORdZCstbqjULSyr5+kr9xI4oYNyKlevhFpB/RJIhLgXsI7r/0BICTLB6I9cWttX5jzLXA/caYPJytLPqrSzXZWcHPAq1tet8XERHa6DLvsAdfMgMRSTRtAy2SfqJJEK8HbgEqgZ87ZccAv4n2Ra21k7o8Xg4cH+a4sHVu6vm3MNtZubRVPYgiIgKTezwfTXAO/j9ciEUkoQLKEEXSTjTbXFQB3+5R9kzcIxokuq5hmqUeRBERcVhrt/co2m6M+STBvYQfdCEkkYSoqm2isbmtV/mIknwqahpdiEhE4iGaVUyzgf8BrgXGAHuAPwG3W2tbEhPe4NDZg6gEUUREQisGyt0OQiSebv3t8pDlvhBbgYnI4BHNENM7gFMJLhazneAKo98l+Kb3lfiHNnhk+YJ/CNv9ShBFRDKdMeZPdJ+NUACcAzziTkQiyeXzhl2nSUQGgWgSxI8CM52hpgDWGPMOsJoMTxA9nmCCqGH4IiICbOrxvB64z1r7ghvBiCSbehBFBrdoEsRwv+0Z/1fAyQ81UVtERLDW3uZ2DCJu8ipBFBnUokkQHwP+YYy5DejYxP5/SNG9CZPJg3oQRUQkyBhzF/AXZyXujrIzgY9Za7/sXmQiyeHzKUEUGcyiGST+deAFYAHBTezvBl4Cbk1AXCmtZyLY2YOY/FBERCT1zAXe6lH2NvBxF2IRibs/LF7HvPkvhq0/4ajSJEYjIvHWZw+iMeaCHkUvO/88HMmHzgbC/5VIV11ujh2Zg6gUUURECND7BqwvRJnIoPTqmr191p9kyvnbki1JikZE4q2/Iabh9mvqyIQ6EsWj4hbRIOUB/MoPRUQEXgV+bIz5urXWb4zxAj9wykUGpbfWVzCiJJ/SoXlhjykbmseB2qbOG+ciMjj1mSBaaycnK5DBLvjHUBmiiIjwJeBpYK8xZjswAdgLfNDVqEQG4N4n3+33GC1OI5IeolmkRvrg8WiRGhERAWvtLmPMbIJ7B48HdgJvWGu1Wa5kBKWJIoObEsQ48Xg8+JUhiohkPGPMLKDKWrsCWOGUjTfGDLfWrnY3OhERkb5pwnycqAdRREQcjwDZPcpygD+5EIuIiEhUlCDGiaYgioiIY4K1ttsSjtbazcAkd8IRERGJnIaYxqR3JtjS6ufAoSYXYhERkRSzyxgz21r7TkeBMydxj4sxiSRel49H3/3kyfi0aI3IoKQEMUah/uS9tb4i6XGIiEjK+TXwd2PMHcBmYArwNeB2V6MSSRYPTB5d7HYUIhIjJYgiIiJxZK19wBhzEPgUwVVMdwC3WGv/6m5kIokV0FwbkbSgBFFERCT+lgDNQJnzvNgYM89a+5CLMYlEze8P8LNH3+n/wC40sFRkcFOCKCIiEkfGmKsIrli6CTgOeA+YASwF+k0QjTHTgIVAKVAFXGet3djjmP8GvgL4AR/wgLX2rjg2QwSAtVuq2LirNqJjP3zuFO5/6j2GFeUmOCoRSSStYhpnAe11ISKS6X4MzLPWngjUO19vAN6O8Pz7gAXW2mnAAuD+EMc8Dsy01s4CzgRuMcacMPDQRY7YsPMgv/nrmoiPP3X6SB78xgXkZPsSGJWIJJoSxDg5b9YYAJpa2l2OREREXDbBWvtYj7KFwHX9nWiMGQHMBhY5RYuA2caY8q7HWWsPWWs77kgWENx3UXcoJa7m/7n/oaUfv3BqEiIRkWTSENMYhOokHFVaCIBfPYgiIpmuwhgz0lq7H9hmjDkDOEBwKGh/xgO7rbXtANbadmPMHqe8suuBxpgrgZ8SXCX1W9batdEEWVpaFM3hYZWXD4nLdVJZJrQRurezOsKtu+ZeeiyPvrCx1/mpbLDEORCZ0EZQOxMlaQmiMeZJYDLB+RJ1wM3W2lV9zbWIZB6GWzye7lOwO/b6aW9XgigikuEeAM4mOAz018BLBN/7fhnPF7HWPgU8ZYyZADxpjFlsrbWRnl9VVYffP7D3rPLyIVRWHh7QNVJdJrQRerfz7scjG1paWXmY2z9zGgcPNw+K71Mm/DwzoY2gdkbK6/VEfUMwmUNMP2mtnenMxfgFRybq9zXXIpJ5GCnhva3VALy6Rvsgi4hkMmvtz6y1jzuPHwamASdZa78bwek7gbHGGB+A83WMUx7u9XYAbwBXDDR2kQ7R3DwYXVrI9EnDExiNiCRT0hJEa23XJbCGAv6+5lpEOg8jVeyvaQBg+770v5MhIiKRs9busNaui/DYCmAVMNcpmgustNb2HF46vcvjMuB8IKohpiJ96TlSSkQyR1LnIBpjfg9cTHCLnP+g77kWnj7qKkNdP5R4zLHoOe43Ly8br9fTrbxjxa6sbN+gHQ89WOOORia0EdTOdJIJbYTMaWeEbgQWGmO+B9TgLG5jjFkMfM9a+xZwgzHmYqCV4PvlPdbaf7oVsIiIpI+kJojW2k8DGGOuBX4ORDLcZkAGOsci1LjfpqZW/P5At/KA8xqNja2Dcjx0JozjzoQ2gtqZTjKhjeDO/IpUZq1dD5wWovyyLo+/ktSgREQkY7iyzYW19k8Eh8PsIvxci6jnYbjphKPLACgflu9yJCIiIiKJc+LUMrdDEJEESkqCaIwpMsaM7/L8g0A1EHauRaTzMFLFhSePA6Clze9yJCIiIiIDs7e6we0QRMQlyRpiWgg8ZowpBNoJJocftNYGjDEh51o4+qpzTagBq9m+YK69ZPUerr/0mOQGJCIiIhJHjU2tYeu0gI1IektKguhsFnx6mLqQcy36q0s12VmujNYVERERiTuvV0mgSKZSVhMnPv0hFRERkTTR1+eaQCD2xf9EJPUpQYwTDbcQERGRdNE+gBXgRWRwU4IoIiIiIt2MLi10OwQRcYkSxDi65NTgQq01h5tdjkREREQkdjMmD+9VdtaMUS5EIiLJpgQxjoYW5gJwy4JlLkciIiIiEjt/iHmGs6aWuxCJiCSbEsRYhBmWr5VMRUREZLBrbm2nqaXd7TBExCXJ2gcx7YRak0YJooiIiAx2N9+5hLb2UHfDtXCNSCZQRhNHShBFRERksAudHIpIplBGE0fZPn07RUREJH3c/pnTujzTll4imUBDTOOoMD/b7RBERERE4ibcdhfXX3oMbe3+JEcjIsmgBDGOSobkuh2CiIiISMKdM3OM2yGISIIoQYyjkSX5bocgIiIiElefunw6a7dUMaasAICZR5e5HJGIJJISxBgEwqzi5fF4GFtWyO4D9UmOSERERCQxzjp+NGcdPxqABV85h/xcfXwUSWdaVSVG4aZpzzy6DJ9Xk7hFREQk/Sg5FEl/ShDjzOuFgFaHFhERERGRQUgJYpx58OBXhigiIiIiIoOQEsQ48zrDSwNKEkVEREREZJBRghhnHmf6oXoRRURERERksFGCGGdeT0cPosuBiIiIiIiIREkJYpx19iD6lSGKiIiIiMjgorWKY9FH7ndkDmKSYhERkbRijJkGLARKgSrgOmvtxh7HfBe4BmgHWoFvW2ufT3asIiKSftSDGLPQex16nHLNQRQRkRjdByyw1k4DFgD3hzjmDeAUa+0JwDzgf40x+UmMUURE0lRSehCNMaXAn4ApQAuwEfistbbSGHM6wTe/fGAb8AlrbYVzXti6VKVVTEVEJFbGmBHAbOAip2gRcI8xptxaW9lxXI/ewjUE71qWAruSFauIiKSnZA0xDQB3WGtfBjDG/ByYb4z5DPAIcL21dqkx5n+A+cA8Y4w3XF2SYo7JkVVM3Y1DREQGpfHAbmttO4C1tt0Ys8cprwxzznXAZmttVMlhaWnRgALtUF4+JC7XSWWZ0EYI3c50bHs6tqmnTGgjqJ2JkpQE0VpbDbzcpWgF8DngJKDJWrvUKb+PYE/hvH7qUlbHKqYaYioiIolmjDkX+BFHehwjVlVVN+AF1crLh1BZeXhA10h1mdBGCN/OdGt7Jvw8M6GNoHZGyuv1RH1DMOlzEJ2ewc8BTwETgO0dddbaA4DXGDO8n7qU5Yww1SI1IiISi53AWGOMD8D5OsYp78YYcwbBkTZXWWttUqMUEZG05cYqpncDdcA9wNWJfrF4DKHp2a2bm5eNz+cJ2d07pDi4RkBJSQGlQwfXegGZ0E2fCW0EtTOdZEIbIXPa2R9rbYUxZhUwl2DyNxdY2XX+IYAx5hTgf4GPWGvfSX6kkglCL8cnIukuqQmiMeYXwFTgg9ZavzFmBzCxS30Z4LfWVvdVF81rDnQITahu3aamVtrbAyG7exvqmwE4cKAOf0tbzK+bbJnQTZ8JbQS1M51kQhvBneEzKe5GYKEx5ntADcE5hhhjFgPfs9a+BdxLcAG3+40xHedda61d60K8kqY+ev7RbocgIi5IWoJojPkJwXmFl1trm53it4F8Y8zZzlzDG4HHIqhznSfMbbXORWq0So2IiMTAWrseOC1E+WVdHp+S1KBERCRjJGubi+OAbwEbgOXO3c6t1tqrjTHXErwDmoezlQWA08MYss5tqzcdoL4pdO+gz6tFakREREREZHBK1iqm7xFmKLu1djlwfLR1bgqXHMKRfRDb1YMoIiIiIiKDTNJXMU13Pm/wW6ohpiIiIpKq2v1+ag4393+giGQcJYhx1rEPonoQRUREJFX99eXN3LJgGYfqW7qVr9lc5VJEIpIqlCDGmU9DTEVERCTFdSSC9z/1Hu9sqKS93c9r7+3jlVW7XY5MRNzmxj6I6c2ZaVnb446ciIiISLLU1rewfd8hsnxeqg41MeeEMQA0t7TT3NreuWbCuu01rNteQ3VdC4/+07oZsoikCCWIcXbgYCMAf/7nBmYdXeZyNCIiIpJqqmqbKBmSyx+fW8++qga+fe1JvG0rycvxcdzk4byxbj8zjy4jN9vXeU5LazsVBxsZWpjDkIKcbtfauvcQU8cPY2hhsHzr3kP8aOFb3V7zzBmjCATgc796JWRMoZLDABoNJZKJlCDG2SnTR/LoCxupOtTkdigiIiIyQM8s3cJ9T6zlqrMnc+XZkwHYXVnHQ4vXc8UZExk2JJe8HB+jSwu57Q9vsn3/Ye760hyK8rOZN/9FPMBvvjSHQCDAkIIcqg81cetvlzNlTDGb9xwCYF91AwueWAvATVfN4L6/v8eEkUVMn1jCG+sq+MVNZ3LjL48kdg98/TxWbjjAvU++G3E7vnX/Cg7URvfZZGRJQVTHi0h6UIIYZ/k5vv4PEhERSUNf+PUSSopz+dGnTnM7lAFbsnoPf3x2fefzJ5du5UBtE+t31HQmWnf/bW1n/ccvnMr2/YcB+OJvXuX0Y0cCEHCeA5x+7EhWvL8foDM5BPj271Z0Pu5I+nbsr2PH/joAPvWzl7rF9pk7Xo66PdEmhwCzp5VHfY6IDH5apCbOcrJ9+LweZhw13O1QREREkmLz7lrmzX+RhuY2dlfWux1Ov9ra/WzYeRCA97ZVM2/+i52ree7Yf5h/vbmzW3LYYenavWETrUdf2NjteUci2F9ZqirKz3Y7BBFxiXoQE2DSqCEEtIqpiIikuaraRppb27n9T2+78vobdh5k8uhi2tr9ZGd5yfJFdt/7C79eQkubn1uvmcUv/7IKgC/fvZRjJ5Xw/raaRIY8aAQC+hwjkqmUICZATraP5la/22GIiIgkTCAQ4Pof/jMu16o53EzJkNxuZZt21/LuliqumnMUAOu31zBt/LDO1Tf3VtUz/8/vcN6JY3l55ZGtGe758hwK8sL3fq3bXkNLW/A9umevn5LDI5QfimQuJYgJkJvt43BDq9thiIiIJMx7W6vjcp3l7+7l90+v41ufmM3UccM6y3/i9Eo+/+ZOPn/1DH71v6v58LlHcfkZkwCoawy+z+6sONzteut3HGTbvsNcPWcyHo+HJ5ZsYVdlHacfN4p/LNvKri5DYHcfSP3hsG7RCqYimUsJYgIU5GXRWNHmdhgiIiIJ8/Dz8dkzb+OuWgB++sg73Hnz2RQX5nSrb25pp+ZwMxBc7bODp2Pj4R55zD3OwjEXnTyOxpZ2/rF8GwArNx6IS7yZQjNlRDKXFqlJgILcLBqalSCKiEj6imVVzP7s6a9Hr2vS4un/eo/+a8OA4slkmoMokrmUICZAQV4WTc1t+PXHVUREpE+JWvVU78AD4/PqI6JIptJvfwIU5GYRIHFveiIiIumg4mAjm3bXdj739NcrGKI+XCL4k4ffZs3mqphjy3Slxbn9HyQiaUkJYgJ4nBXWfvqIO8t+i4iIDAaHnb0HI9YlG+zIFcMN1qk42BhTTJnk+kuPCVunQVAimUsJYgJMn1gCwLgRRS5HIiIikrp65iCBAKzcUEl9U/eVwD2hug4jmIMovZ0wpbTz8Tkzx4Q9TtNkRDKXVjFNgHHlRQwtymFMaYHboYiIiMRd3BYw6XGZOxatBODYSSU9Duvr9ZTI9OfS0ybw7Os7ABhTVhjR0NspY4cmOiwRSVHqQUyQ3Gwfza3+uF2vqrap2/LeIiIibolffhj6QpURDA8N2asovXzpIyf0mUIff1Rpr7Ivf3Qm115sEheUiKQ0JYgJkpvto7mlPWx9IBDgnQ2VEQ/huPW3y/n271bEKzwREZGYxWsT9XBvgZUHu2+h0VcyqJGQfcvL8fVZ7/N2/97OOrqME6aUkp2lj4gimUq//QmSl+OjqSX8Xohvrq/gnr+t5V9v7kxiVCIiIgPXX1LWmIS9gPtd8TTNjS0rdDsEEUlTShATZGhhDrV9rM7W5PQu7qqsi+q6B+uaBxSXiIikNmPMNGPMa8aYDc7XqSGOudgY85YxptkY84tkx9hfgrh2S2TbS0Q6l7GvHstM7UC8bd6pESfJGZ5Li0iUlCAmyPvbathb1UBLa+hhpjnO0I3WtujmKS5+bfuAYxMRkZR2H7DAWjsNWADcH+KYLcCngZ8nM7AO/SV2iR72+a+3dvKjhW8l9kVSzIfPParbc6/Xw4PfuCCicwNhn4iI9JaUVUydu5sfBiYBx1tr33XKpwELgVKgCrjOWruxv7rBoMEZXlPX2Mrw7N7j/7N8wQTxbVsZ1XXHlGtIiYhIujLGjABmAxc5RYuAe4wx5dYeecOw1m5yjr8q+VH2n2PEa45ih65zEA/Vt7DohSMfB7bvOxzX10pVRfnZUR1fMiSXmsPRjzoaWpQT9Tkikl6S1YP4JHAO0LP7q6+7pJHcQU1Zl58xsc96rzMpvN0f3Ztoe7tu/YmIpLHxwG5rbTuA83WPU54y+h0aGuFbVU0M0yZu/e3yqM8ZDO796jlxvd6XPnIC08YNZfLo4qiGmF7zgV4jmkUkwySlB9FauxTAmCNLJvd1l5TgcPl+76CmslHDg3sghksA6xuPbAIcCATw9JhI0NjcRktrO0OLcru9EYcbsioiIhKN0tKimM9t6LGRfU9DhuRRXj6kz2MCgQC/e+r9iF6vqi44pz83LzvqqRmDwfDiXMaPLeEfv/wQH7zl7yGPGTWi+/ezv+/vSTPGcNKMMQDk5x/pFcwvOPK4vHwIHzx3Cqs2HQDggpPHM27MsJjaMJj0971LB5nQRlA7EyUpCWIYve6SGmM67pJ6+qiLKkEcyBtgh3A/lL5+WMOGHgRg6LACyst7x/Diyt2dj4uHFZCXk8XX736V02eM4j/Pn8qnb/8X+6sb+McvP0RTl9XgsnKyEvafJBN+yTKhjaB2ppNMaCNkTjsjsBMYa4zxOe99PmCMUx5XVVV1+KMcxdKhoanvVUoPHW6isrLvoZ8bdh6M+PX+vmQzAM39JKaD1R2fO7PX9+uy0yeyeEVw4NVD37yA1U4S16Hj+F/cdCZ1ja384A9vhqwHaGg8smheY0NLt2Mmlxfy6Sum8/un1+Fva+/35zbYlZcPURvThNoZGa/XE3U+5GaCmBQDeQOEvn8off2w6pxhM3v21ZITYqzN1HFDO+dNfOHnL/GRc49i3bZq1m2r5rgJw9hf3dD5Gl3nENTUNibklyETfskyoY2gdqaTTGgjuPPml6qstRXGmFXAXOAR5+vK1Bs9M/Ahpn1tBRVOpHsHp4pb557Izxet7FX+0DcvYGb32xYAABg0SURBVN78Fzufe0MsR+rtsT9huBVLhxfnMbw4r884up46qrSAS0+bQHWXzxanTh9JTX0r588c3ed1RCQzuLmKaeddUoAed0n7qhsUVm4Mvpf//dWtIevbuswl3F/dwIIn3u18/rV7j8yvWL+9hlsWLOt83qwhpiIi6e5G4GZjzAbgZuc5xpjFxpiTncdnG2N2AV8FPmuM2WWMuSRZAfZ337XrIjWNzW3s2H+YF9/Zxbz5L1Lf2QsY/eYLr723P+pz3DR9YknYup9+9vSQ5RefEpxump/rY9bRZXGN58SpZcw5YTQfPf9oPnvlcZ3lWT4v119xHAV50S2EIyLpybUexP7ukg6OO6jhzZk5hjfWVTC6NPSqoys3RNaUPz63vttzzUEUEUlv1tr1wGkhyi/r8ngpMC6ZcXXV3yI1r727j4mjihlbVsg9f1vLuu01jCzJB6DmcDOFedkDGt3jlru+NIcv/uZVAK44cyJb9xzivW01MV1rZEkBZUPzOFDb1K38w+ceRX5uFheeNJ7/OHVCxNe78UPHsXTtXt7dUh32mCljh/Za80BEpKek9CAaY+5y7nSOA14wxrznVIW8SxpBXcqbPiF41/C5N3ZQUdPAhp0HmTf/RSpqGggEAtTWt/RzhaCeb8LL1u6juUVJooiIuKe/1O69bTV89/evA7BxV3CuYcfbmYfgKJu7Hl+TuADjpLQ4j9tuOKPzedetJqaOGxZ+3Cd0JndXz5kc9pjvXX8Kt807tVtZdpaPD509mewsLx6PJ+KE7tTpI/nqx2Zx01UzOEdDRUVkAJK1iukXgS+GKA95l7S/usGg69yBb96/ovPxivf2U+7cRR1WlMPBur4Txcr/3969B8dVnncc/55dXSxbtmTL8l2yDbZe4xu2sTE2DgkOJiS1AwESQ7gmJA00dUobT0Iypcnk0lICoSWXwoRhmiGUNpAphLYJpNOS4AQCjcGAk7w24ItsbJBtfJEt67anf5yzq9VqJe2upN2ze36fGdDue27v61erZ59z3vOeo6f7lD31wl4+vKb/gCMiIjKScrkVMHnYaeqEK0H16Q3zmTV1XK+yL358Kd/+8TZmJ5VPrRtNxHG4af1ZPPbMG3x+45JEYrfh/NlcsnImdzy8lV0HjjM96XnG1VXlGT/fcPrEzO6zXT5vEsvnTepVNn/2BH722700zSj9GUpFZOhKfpKaoHnqxWbmNXp/oM9fNJX62ir++Wd/HGSr3pKTz3eOtvHEs7u49uImqirVnSIikgc5ZIiJK4iOM+g9jEERcRzGj63sVWYax3P/5vcBsHD2BLbvOsKmKxYnHm+1+aqlffZTXhbh9huW09rWSWV5NKe61NWM6jO5TaYWzJrA/ZvfR3lZIaeeEJFiob8UI6gs2veft629i5d2emdON6yexQVnT+PB29Zmtd//fG4PsZhLe0c3z257i+e2H+TZVw4MS51FREQGk0uCF79lwnHIaJbTIIhEBh7iefGKBu7ZtCaRHA6muqq8YEmakkMRyZQuOY2gNYun8kzS8w5TJf+x/tYtq9l/qJV/eDT9PRnXXdzEQ0/vALyZTL/y4AvsP3QysXywhxaLiIgUUnJSOdgkN0ER8cP01e+fy7gxFX2WO45DTZpyEZFipgQxB5PHVzFtYvrZSZNVVQw8jCT5rGRdzSjqanqeY5Q6s9mFy2ZQWRHlgf/4A0Cv5BCgoyuWUd1FRESGKpsELxaL/+zZppiGmAKs8x89ISISBhpvkINIxEk7fDRV6nCO265Zlnjd3wxjS+d6zzy64zOrmDOjptey1Qv7n5Xs57/dO2h9REREhkM2FwDjD7ePz9595yMv8dz2gyNRrWEXjQTvkRC337CcO29ZNfiKIiI50hXEHGQaGCv8G9EvXDqda9Y19ZrBbW4/M4ltumJx4vW8xvG8vu8Y16xrSpTdfOkC7ntie7pNRURE8iLTK4hHjvedifvYILN3B0kkgAni7JRZVUVEhpsSxBy4DPjoo4R1yxtw8IameEHGYUZ9NftaWplaN/gQ1TWLp3LoWBurFkxOlK2YN4mtO1p44Q/v5Fx/ERGRocj0AuKWIptALR6j44KYIIqIjDQNMR1B5WURPnjezF7DUW+5bAEXLZ/BrCljB91+Um0Vf7phAaNH9TwjyXEclvjDUFP9+T2/oq29K/H+f7buY0fz0SG0QEREpK9MryDGimQyms1XLQFg/eqZfOXGFYnySIYPqRcRKSVKEHMxhIA3tW4MH7+oaUhnJctT7n+cP2s8AKfau2h+xzvzGYu5/OjpHdzx8NacjyMiIpJOahSMJ1ipfv1qcdxrOH/WBB68bS3nnjWZmUkncDs6uwtYKxGRwtAQ0xwN9FykkbZ0bj3nNNVz9GQ7164zbHnlAL/f/S4AHV1eMOvs1qymIiIyMuLnSefMqGH+zPH9njc9nOYexGKSPLu4iEhYKEHMQaEHzEQiDp+9fFHi/dMvNided3Z6iWG3EkQRERkh8SGml713DvMbatj79okC12hkjKrQ1yQRCR8NMc1RkO5KSL7vsN0fDtPVXeg0VkRESlX8imF8ME3j5LF8/aZzC1ehYfbX1y/nMx9eUOhqiIgUhBLEXAQs92qcXJ143dYRTxB1BVFEREZGPAwm324xvb46/cpF6Ixp41g5f/LgK4qIlCAliLkK0CXE9atn8YFzGwB47rWDHGttpyvWk8V2x5QsiojI8IkPMS2FST7Xr55Z6CqIiASKEsQcuAG7hFgWjbBx7VwAXt9/jLv/bVuvexDbO5QgiojIMEoMMS3+DPHyC84sdBVERAJFCWKOghwS97e09roH8fipjgLWRkRESk38+YZBjoUiIpIbTc+Vg5ajpwP98FyX3vcgtp7qhAmFq4+IiJSmUriCKCIivekKYpbi9128/W5bgWsysNa2zp7XpzsHWFNERCQ7qbOYxilfFBEpfkoQs9QdC9b9h8nmNdYmXt/z422J1yfblCCKiMjwid+Lnzqa5i+uXFyI6mRtzCgNoBIR6Y8SxCzFApwgTqkbk7b8+EndgygiIsPHTTznond5zZjKvNclG9/89EoAqqvKuf2G5dz1Z6sLXCMRkeBRgpilIF9BvGrtHJoaavuUHzp+ugC1ERGRUhWNeJlhebS4vkYk7pl0HGZPHceEcaMKWyERkQAqrr/sARDkBLGiPMpt1yzj7s+e36v8f7fuL1CNRESkFDVMqubmSxeweM7EXuVBewxUKlezr4qIDCrwg/CNMU3AD4E64DBwvbV2Zz6O3R2LJYJJ3Cl/wpc/WRXcB+vWVlf0KTva2k5leRSAyvIokYjDkeOnGTu6gvKy4J0n6OqOUZblmenWtk6iEYeqysD/WouI9CuTuGeMiQL3ApfgTV59h7X2gXzV0XEczj1rMtGUv9PTJ46hcVI1V154Jm8faePhX+zodx/vXTKNX778VkbHW7VgMs9tf3tIdU6myXRERPpXDN+k7wO+Z639kTHmWuB+YG0+DvzwL3by8uuHmDC2knGjKzh0rI19LScBOHD4VD6qkBPHcTh/4RSOtrZz0fIG/vGxV/ir7/467brjRpez8Iw6aseNoquzOzHhgItLR1eMqooyXNelO+ay5+AJpk0cQ82YClx6zsTGXO/ezEgEHP+8bDz4xlwoizi91o/X0XVd73jxdWMu7Z3dvPbmEfYfOsklKxsZVeEltfGT0p3dMSrKIrguRPz94rrgOPz7r94E4LI1s4lEHI6d7GDc6HKi0Qiu61JWUca7R9uorirHcWB/y0maGmqpqxlFJOLV3HHiP/3XjtcmxwGcngkZ4j97r5f0Omk/OI53qd5J3q7veqn7SRzHAW80V3ybnjppinmRkpRJ3LsGmAPMxUskXzLG/Le1dndea5qivCzKVz95LgALZ8P7z5lB8zut/OSXb7B915Feo3BuuGQeZ8+ZyL2PvTLofm9aP5+JNVU8+Zvdg667euEUfvPawV5lTQ21rFowmdpq7x7JS1Y2ZtEqEZFwCXSCaIyZBCwD1vlFjwDfNcbUW2tbRvr4K+ZN4tU3D/PmW8cZXVlGVWU0sexT688a6cMPyU3r5wNeUnbpmtkcOHySIyfaeX3fMWZNGcvugycAL5jvaD5KR1eM9s5uYjG319Cb7pjrJU8OdHTGsM1H+xzLwUvWYq4LLr0GGDmQ1YCjivIIHZ3eMxx//tu9WbU57vEtuzJe9/nfD98Z6ULxc8ee5DWSlLymSSoT2zmOl3imSzL9pDt+n9Gw1LOfXQ18hPRLHQei0QixWCxxUiIuPsQt5eJ/4t8gi4OnbO+A6+09vlnq7zpJCb//cSDipK9LJqLRCN1JzzSN6+8RA8MlfmKiv927/v+ST/zET7J4/z6O/2+QfsChk/LuxvXzOWNy9bDVv5hlEfc2Aj+w1saAFmPM48BHgW/ltcIZaJhUza0fPTvx/gdPbk9cDVySNER1zeKp7Dl4gs9vXMKt39nCvMZaFp5Rx4JZE4g4DhNr098veOHS6Zxq72L+rPHUjKlg0Rl1XHtxE7sOnGBeY22fE2kP3paXc8wiIkUr0Aki0ADst9Z2A1hru40xb/nlGSWIdXW5f+morx/LBcuL/yzjpz4yfNOOu67b68vpQFew4l8cU9eP78NxvCuM8TfxRDNxhjnlW3D8SN2xGJGIlxyQ+CLqLYs43hfUWMwlGo3QlfTlOuJAJNLzhfv4yQ46uro53tpBd8xNfJmN16/np5d09C5zvbrj/3RJJMixfveTphxwY97Pnu39/cZ69p/YhqQ6DbTfpC/vqcfy9urXM823d9d1E/2UOmtvvN+yle44Xj36P33Q3zbxOiaSlHR1cnr9SKyb6f7T1TN+HAen52p4/D09J0dSr5THXLfXVeHE56JvdbPiOI7XPwMkcn3bkdlK8fYOXoeepNv7fXL7fMYzucpdPbqC+vqxmdQuDDKNe43AnqT3e/11MjaU+Jgs27778ifP6/X+nr98L9t2tHDF2rmJsifvvrTPdh9Z20R7l8uK+VOYOnEMr7zewqpF0/o9TsP08VnVayBh+f1UO0tHGNoIaudICXqCOGSHD7cO6dEU9fVjaWk5MYw1CqYwtDNdG8uBujHlhanQCAlDX0I42hmGNsLQ2xmJOMOW7ITJUOMjDM/vaE1llAsWTcloPxctmw7AqdbTzJmSn8+HPoelJQztDEMbQe3MVC4xMnizk/TWDEz3b8aP35Q/zS8XEREpNZnGvb1A8mxpjWnWERERyVqgE0Rr7TvAy8DVftHVwEv5uP9QREQk37KIe48CnzbGRIwx9cBlwGP5q6mIiJSqQCeIvpuBTcaYHcAm/72IiEipShv3jDH/ZYxZ7q/zEPAmsBN4HviatTbzGbpERET6Efh7EK21fwRWFroeIiIi+dBf3LPWfijpdTdwSz7rJSIi4VAMVxBFREREREQkD5QgioiIiIiICKAEUURERERERHxKEEVERERERARQgigiIiIiIiK+wM9iOgRRgEjEGfKOhmMfxSAM7QxDG0HtLCVhaCMMrZ1J20aHpTKlb9ji43DuJ8jC0EZQO0tJGNoIameW22YcIx3XdXM+YMCtAZ4tdCVERCRv3gNsKXQlioDio4hI+GQcI0s5QawEVgAHgO4C10VEREZOFJgKvAi0F7guxUDxUUQkPLKOkaWcIIqIiIiIiEgWNEmNiIiIiIiIAEoQRURERERExKcEUURERERERAAliCIiIiIiIuJTgigiIiIiIiKAEkQRERERERHxKUEUERERERERAMoKXYGgMsY0AT8E6oDDwPXW2p2FrVVujDG7gdP+fwBftNY+ZYw5D7gfqAJ2A9daa9/xt+l3WVAYY+4CrgBmAYusta/55f32Xa7LCmWANu4mTZ/6y4quX40xdcBDwJlAB7AT+Iy1tiXX9gStrYO00QVeBWL+6tdZa1/1t9sAfAvv7/XvgE9Ya08NtqyQjDGPA7Px2tMKbLLWvlxKn82wK6U+KcUYGYb4COGIkWGIj36dQhEjiyU+6gpi/+4DvmetbQK+h/dBKmZXWmuX+P89ZYyJAD8CPuu38VfAHQADLQuYx4ELgD0p5QP1Xa7LCqW/NkJKn8LAfRfwfnWBO621xlq7CHgDuCPX9gS0rWnbmLR8dVJ/xgNfNfADYIO1dg5wAtg82LIAuMFae7a1dilwF/CgX15Kn82wK7U+KbUYGYb4COGIkWGIjxCeGFkU8VEJYhrGmEnAMuARv+gRYJkxpr5wtRp25wCnrbVb/Pf3AR/LYFlgWGu3WGubk8sG6rtcl410OwaSro2DKMp+tdYesdY+k1T0PDCT3NsTuLYO0MaBfBD4v6SzgfcBGzNYVlDW2mNJb2uAWKl9NsMsJH1SVH9fUoUhPkI4YmQY4iOEJ0YWS3xUgpheA7DfWtsN4P98yy8vVg8bY14xxnzfGFMLNJJ0xs1aewiIGGMmDLIs6Abqu1yXBVVqn0IJ9Kt/dvMW4Kfk3p5AtzWljXHPGGNeNsb8nTGm0i/r1Q5gLz2/kwMtKzhjzAPGmL3AN4EbCNdns9SVYp+EIUaG7TNYcjEyDPERSj9GFkN8VIIYDu+x1p4NrAAc4LsFro8MXSn36XfwxuWXUptSpbax0Vq7HG+o1Hzg9kJVbLhYaz9lrW0Evox3D4hIUJXy39OwKtU+DUN8hBKPkcUQH5UgptcMTDfGRAH8n9P88qITH35hrW0Hvg+cj3cmJXHp3hgzEYhZa48MsizoBuq7XJcFTj99CkXer/6EA3OBjdbaGLm3J7BtTdPG5P48DjxAP/2Jd0a0OYNlgWGtfQi4ENhHCD6bIVFSfRKiGBmK+AilGSPDEB8hXDEyyPFRCWIa1pvJ6WXgar/oauAla21L4WqVG2PMGGNMjf/aAa7Ca9vvgCpjzBp/1ZuBR/3XAy0LtIH6Ltdl+at9ZgboUyjifjXG/C3evRGX+UEdcm9PINuaro3GmPHGmCr/dRlwJT39+XNghTFmrv/+ZuDHGSwrGGNMtTGmIen9BuAIUPKfzbAopT4JU4wMQ3yE0oyRYYiPUPoxspjio+O67lD3UZKMMfPwpo0dD7yLN22sLWytsmeMOQP4CRD1//s98Dlr7QFjzGq82Y5G0TPN8dv+dv0uCwpjzL3A5cAU4BBw2Fq7YKC+y3VZoaRrI7CBfvrU36bo+tUYswB4DdgBtPnFu6y1H8m1PUFra39tBO7Eq6cLlAO/AW611rb6213qrxMFXgJutNaeHGxZoRhjJgNPAGOAbrzgt9lau7WUPpthVyp9UqoxMgzxEcIRI8MQH/06lXyMLKb4qARRREREREREAA0xFREREREREZ8SRBEREREREQGUIIqIiIiIiIhPCaKIiIiIiIgAShBFRERERETEpwRRREREREREACgrdAVEpDCMMbPwnjFUbq3tKnB1REREAkMxUsJMVxBFREREREQEUIIoIiIiIiIiPsd13ULXQUR8xphpwHeAC4BW4B5r7b3GmK8CC4Fu4EPATuAT1tpt/nZnAf8ELAH2A1+y1v7UX1YFfAO4EqgFXgXWAZPxhs/cCHwdGO0f75v5aKuIiEg2FCNF8kNXEEUCwhgTAZ4EtgHTgfcDtxpjPuCvcinwKDAB+BfgcWNMuTGm3N/uaWASsAl42Bhj/O3uAs4BVvvbfgGIJR16DWD84/2NH0hFREQCQzFSJH90BVEkIIwxK4FHrbWNSWVfApqAPcAl1trz/PII3lnQj/mrPgpMs9bG/OWPABb4GnASOC9+JjVp37Pwzo42WGv3+WUvAN+21v7rSLVTREQkW4qRIvmjWUxFgmMmMM0YczSpLAo8ixf8muOF1tqYMWYfMM0vao4HPt8evDOsE4FRwBsDHPdg0utTQHXOLRARERkZipEieaIEUSQ4moFd1tq5qQv8+ysakt5HgBnAW35RgzEmkhQAG4EdwCHgNHAm3rAcERGRYqQYKZInShBFguMF4IQx5ovAvUAHcBZQ5S8/xxhzOfBT4HNAO/A84OCd1fyCMeZu4HxgA7DCP4v6IPBtY8x1wNvAucDW/DVLRERkyBQjRfJEk9SIBIS1thtYjzfL2i68M5sPADX+Kk8AG4F3geuAy621ndbaDrxg90F/m+8D11tr/+hvtxlvVrYXgSPA36PPvoiIFBHFSJH80SQ1IkXAHz4zx1p7baHrIiIiEiSKkSLDS2dIREREREREBFCCKCIiIiIiIj4NMRURERERERFAVxBFRERERETEpwRRREREREREACWIIiIiIiIi4lOCKCIiIiIiIoASRBEREREREfH9P1CJE9u9thJgAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -258,23 +276,36 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "sentence_generated = tag\n", + "onehot = embed_to_onehot(tag, text_vocab)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "def generate_based_sequence(length_sentence, argmax = False):\n", " sentence_generated = tag\n", " onehot = embed_to_onehot(tag, text_vocab)\n", - " model.initial_state = model.rnn_cells.zero_state(\n", - " dtype = tf.float32, batch_size = batch_size)\n", - " for i in range(len(tag)):\n", + " batch_x = np.zeros((1, 1, len(text_vocab)))\n", + " batch_x[:, 0, :] = onehot[0, :]\n", + " last_state, prob = sess.run(\n", + " [model.last_state, model.final_outputs],\n", + " feed_dict = {model.X: batch_x},\n", + " )\n", + " for i in range(1, len(tag), 1):\n", " batch_x = np.zeros((1, 1, len(text_vocab)))\n", " batch_x[:, 0, :] = onehot[i, :]\n", " last_state, prob = sess.run(\n", " [model.last_state, model.final_outputs],\n", - " feed_dict = {model.X: batch_x},\n", + " feed_dict = {model.X: batch_x, model.initial_state: last_state},\n", " )\n", - " model.initial_state = last_state\n", "\n", " for i in range(length_sentence):\n", " if argmax:\n", @@ -288,23 +319,22 @@ " batch_x[:, 0, :] = onehot[0, :]\n", " last_state, prob = sess.run(\n", " [model.last_state, model.final_outputs],\n", - " feed_dict = {model.X: batch_x},\n", + " feed_dict = {model.X: batch_x, model.initial_state: last_state},\n", " )\n", - " model.initial_state = last_state\n", "\n", " return sentence_generated" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll\n" + "Anddqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\n" ] } ], @@ -314,14 +344,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tillllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll\n" + "AnddPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP\n" ] } ], diff --git a/generator/9.char-generator-lstm-luong.ipynb b/generator/9.char-generator-lstm-luong.ipynb index d31d8f7..9ba6db0 100644 --- a/generator/9.char-generator-lstm-luong.ipynb +++ b/generator/9.char-generator-lstm-luong.ipynb @@ -51,20 +51,40 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "65" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(text_vocab)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "learning_rate = 0.01\n", - "batch_size = 128\n", + "batch_size = 32\n", "sequence_length = 64\n", "epoch = 3000\n", "num_layers = 2\n", - "size_layer = 512\n", + "size_layer = 256\n", "possible_batch_id = range(len(text) - sequence_length - 1)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -74,12 +94,9 @@ " ):\n", " def lstm_cell():\n", " return tf.nn.rnn_cell.LSTMCell(\n", - " size_layer, sequence_length, state_is_tuple = False\n", + " size_layer, sequence_length\n", " )\n", "\n", - " self.rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n", - " [lstm_cell() for _ in range(num_layers)], state_is_tuple = False\n", - " )\n", " self.X = tf.placeholder(tf.float32, (None, None, dimension))\n", " self.Y = tf.placeholder(tf.float32, (None, None, dimension))\n", " attention_mechanism = tf.contrib.seq2seq.LuongAttention(\n", @@ -87,8 +104,7 @@ " )\n", " self.rnn_cells = tf.contrib.seq2seq.AttentionWrapper(\n", " cell = tf.nn.rnn_cell.MultiRNNCell(\n", - " [lstm_cell() for _ in range(num_layers)],\n", - " state_is_tuple = False,\n", + " [lstm_cell() for _ in range(num_layers)]\n", " ),\n", " attention_mechanism = attention_mechanism,\n", " attention_layer_size = size_layer,\n", @@ -128,24 +144,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.\n", - "WARNING:tensorflow:From :43: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", + "WARNING:tensorflow:From :39: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "\n", "Future major versions of TensorFlow will allow gradients to flow\n", "into the labels input on backprop by default.\n", "\n", - "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n", + "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n", "\n" ] } @@ -159,14 +171,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "than\n" + "seem\n" ] } ], @@ -178,18 +190,25 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def train_random_sequence():\n", " LOST, ACCURACY = [], []\n", " pbar = tqdm(range(epoch), desc = 'epoch')\n", + " batch_x = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", + " batch_y = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", + " batch_id = random.sample(possible_batch_id, batch_size)\n", + " for n in range(sequence_length):\n", + " id1 = [k + n for k in batch_id]\n", + " id2 = [k + n + 1 for k in batch_id]\n", + " batch_x[:,n,:] = onehot[id1, :]\n", + " batch_y[:,n,:] = onehot[id2, :]\n", + " last_state, _ = sess.run([model.last_state, model.optimizer], feed_dict = {model.X: batch_x,\n", + " model.Y: batch_y})\n", " for i in pbar:\n", " last_time = time.time()\n", - " model.initial_state = model.rnn_cells.zero_state(\n", - " dtype = tf.float32, batch_size = batch_size)\n", - " init_value = np.zeros((batch_size, num_layers * 2 * size_layer))\n", " batch_x = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", " batch_y = np.zeros((batch_size, sequence_length, len(text_vocab)))\n", " batch_id = random.sample(possible_batch_id, batch_size)\n", @@ -198,27 +217,26 @@ " id2 = [k + n + 1 for k in batch_id]\n", " batch_x[:,n,:] = onehot[id1, :]\n", " batch_y[:,n,:] = onehot[id2, :]\n", - " last_state, _, loss = sess.run([model.last_state, model.optimizer, model.cost], \n", + " last_state, _, loss, accuracy = sess.run([model.last_state, model.optimizer, \n", + " model.cost, model.accuracy], \n", " feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", - " accuracy = sess.run(model.accuracy, feed_dict = {model.X: batch_x, \n", - " model.Y: batch_y})\n", + " model.Y: batch_y,\n", + " model.initial_state: last_state})\n", " ACCURACY.append(accuracy); LOST.append(loss)\n", - " model.initial_state = last_state\n", " pbar.set_postfix(cost = loss, accuracy = accuracy)\n", " return LOST, ACCURACY" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "epoch: 100%|██████████| 3000/3000 [37:47<00:00, 1.03it/s, accuracy=0.724, cost=0.994] \n" + "epoch: 100%|██████████| 3000/3000 [05:20<00:00, 9.56it/s, accuracy=0.387, cost=2.12] \n" ] } ], @@ -228,12 +246,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -258,23 +276,36 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "sentence_generated = tag\n", + "onehot = embed_to_onehot(tag, text_vocab)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def generate_based_sequence(length_sentence, argmax = False):\n", " sentence_generated = tag\n", " onehot = embed_to_onehot(tag, text_vocab)\n", - " model.initial_state = model.rnn_cells.zero_state(\n", - " dtype = tf.float32, batch_size = batch_size)\n", - " for i in range(len(tag)):\n", + " batch_x = np.zeros((1, 1, len(text_vocab)))\n", + " batch_x[:, 0, :] = onehot[0, :]\n", + " last_state, prob = sess.run(\n", + " [model.last_state, model.final_outputs],\n", + " feed_dict = {model.X: batch_x},\n", + " )\n", + " for i in range(1, len(tag), 1):\n", " batch_x = np.zeros((1, 1, len(text_vocab)))\n", " batch_x[:, 0, :] = onehot[i, :]\n", " last_state, prob = sess.run(\n", " [model.last_state, model.final_outputs],\n", - " feed_dict = {model.X: batch_x},\n", + " feed_dict = {model.X: batch_x, model.initial_state: last_state},\n", " )\n", - " model.initial_state = last_state\n", "\n", " for i in range(length_sentence):\n", " if argmax:\n", @@ -288,23 +319,22 @@ " batch_x[:, 0, :] = onehot[0, :]\n", " last_state, prob = sess.run(\n", " [model.last_state, model.final_outputs],\n", - " feed_dict = {model.X: batch_x},\n", + " feed_dict = {model.X: batch_x, model.initial_state: last_state},\n", " )\n", - " model.initial_state = last_state\n", "\n", " return sentence_generated" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "thannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn\n" + "seem33nnQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ\n" ] } ], @@ -314,14 +344,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "thannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn\n" + "seem33g$333,,,,,,,,,,,&NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN\n" ] } ], diff --git a/neural-machine-translation/50.byte-net-greedy.ipynb b/neural-machine-translation/50.byte-net-greedy.ipynb new file mode 100644 index 0000000..99e8e39 --- /dev/null +++ b/neural-machine-translation/50.byte-net-greedy.ipynb @@ -0,0 +1,570 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from sklearn.utils import shuffle\n", + "import re\n", + "import time\n", + "import collections\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dataset(words, n_words, atleast=1):\n", + " count = [['PAD', 0], ['GO', 1], ['EOS', 2], ['UNK', 3]]\n", + " counter = collections.Counter(words).most_common(n_words)\n", + " counter = [i for i in counter if i[1] >= atleast]\n", + " count.extend(counter)\n", + " dictionary = dict()\n", + " for word, _ in count:\n", + " dictionary[word] = len(dictionary)\n", + " data = list()\n", + " unk_count = 0\n", + " for word in words:\n", + " index = dictionary.get(word, 0)\n", + " if index == 0:\n", + " unk_count += 1\n", + " data.append(index)\n", + " count[0][1] = unk_count\n", + " reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n", + " return data, count, dictionary, reversed_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len from: 500, len to: 500\n" + ] + } + ], + "source": [ + "with open('english-train', 'r') as fopen:\n", + " text_from = fopen.read().lower().split('\\n')[:-1]\n", + "with open('vietnam-train', 'r') as fopen:\n", + " text_to = fopen.read().lower().split('\\n')[:-1]\n", + "print('len from: %d, len to: %d'%(len(text_from), len(text_to)))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vocab from size: 1935\n", + "Most common words [(',', 564), ('.', 477), ('the', 368), ('and', 286), ('to', 242), ('of', 220)]\n", + "Sample data [482, 483, 78, 6, 137, 484, 10, 226, 787, 14] ['rachel', 'pike', ':', 'the', 'science', 'behind', 'a', 'climate', 'headline', 'in']\n" + ] + } + ], + "source": [ + "concat_from = ' '.join(text_from).split()\n", + "vocabulary_size_from = len(list(set(concat_from)))\n", + "data_from, count_from, dictionary_from, rev_dictionary_from = build_dataset(concat_from, vocabulary_size_from)\n", + "print('vocab from size: %d'%(vocabulary_size_from))\n", + "print('Most common words', count_from[4:10])\n", + "print('Sample data', data_from[:10], [rev_dictionary_from[i] for i in data_from[:10]])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vocab to size: 1461\n", + "Most common words [(',', 472), ('.', 430), ('tôi', 283), ('và', 230), ('có', 199), ('chúng', 196)]\n", + "Sample data [84, 22, 668, 73, 10, 389, 110, 34, 81, 299] ['khoa', 'học', 'đằng', 'sau', 'một', 'tiêu', 'đề', 'về', 'khí', 'hậu']\n" + ] + } + ], + "source": [ + "concat_to = ' '.join(text_to).split()\n", + "vocabulary_size_to = len(list(set(concat_to)))\n", + "data_to, count_to, dictionary_to, rev_dictionary_to = build_dataset(concat_to, vocabulary_size_to)\n", + "print('vocab to size: %d'%(vocabulary_size_to))\n", + "print('Most common words', count_to[4:10])\n", + "print('Sample data', data_to[:10], [rev_dictionary_to[i] for i in data_to[:10]])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "GO = dictionary_from['GO']\n", + "PAD = dictionary_from['PAD']\n", + "EOS = dictionary_from['EOS']\n", + "UNK = dictionary_from['UNK']" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(len(text_to)):\n", + " text_to[i] += ' EOS'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def str_idx(corpus, dic):\n", + " X = []\n", + " for i in corpus:\n", + " ints = []\n", + " for k in i.split():\n", + " ints.append(dic.get(k,UNK))\n", + " X.append(ints)\n", + " return X\n", + "\n", + "def pad_sentence_batch(sentence_batch, sentence_batch_y, pad_int):\n", + " x, y = [], []\n", + " max_sentence_len = max([len(sentence) for sentence in sentence_batch])\n", + " max_sentence_len_y = max([len(sentence) for sentence in sentence_batch_y])\n", + " max_sentence_len = max(max_sentence_len, max_sentence_len_y)\n", + " for no, sentence in enumerate(sentence_batch):\n", + " x.append(sentence + [pad_int] * (max_sentence_len - len(sentence)))\n", + " y.append(sentence_batch_y[no] + [pad_int] * (max_sentence_len - len(sentence_batch_y[no])))\n", + " return x, y" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "X = str_idx(text_from, dictionary_from)\n", + "Y = str_idx(text_to, dictionary_to)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "maxlen_question = max([len(x) for x in X]) * 2\n", + "maxlen_answer = max([len(y) for y in Y]) * 2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def layer_normalization(inputs, block_name, reuse, epsilon=1e-8):\n", + " with tf.variable_scope(block_name, reuse = reuse):\n", + " mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)\n", + " normalized = (inputs - mean) / (tf.sqrt(variance + epsilon))\n", + "\n", + " params_shape = inputs.get_shape()[-1:]\n", + " gamma = tf.get_variable('gamma', params_shape, tf.float32, tf.ones_initializer())\n", + " beta = tf.get_variable('beta', params_shape, tf.float32, tf.zeros_initializer())\n", + "\n", + " outputs = gamma * normalized + beta\n", + " return outputs\n", + "\n", + "def conv1d(input_, output_channels, block_name, reuse, dilation = 1, filter_width = 1, causal = False):\n", + " with tf.variable_scope(block_name, reuse = reuse):\n", + " w = tf.get_variable('w', [1, filter_width, int(input_.get_shape()[-1]), output_channels],\n", + " tf.float32, tf.initializers.random_normal(stddev = 0.02))\n", + " b = tf.get_variable('b', [output_channels],\n", + " tf.float32, tf.zeros_initializer())\n", + " if causal:\n", + " padding = [[0, 0], [(filter_width - 1) * dilation, 0], [0, 0]]\n", + " padded = tf.pad(input_, padding)\n", + " input_expanded = tf.expand_dims(padded, dim = 1)\n", + " out = tf.nn.atrous_conv2d(input_expanded, w, rate = dilation, padding = 'VALID') + b\n", + " else:\n", + " input_expanded = tf.expand_dims(input_, dim = 1)\n", + " out = tf.nn.atrous_conv2d(input_expanded, w, rate = dilation, padding = 'SAME') + b\n", + " return tf.squeeze(out, [1])\n", + "\n", + "def bytenet_residual_block(input_, dilation, layer_no, \n", + " residual_channels, filter_width, block_type,\n", + " causal = True, reuse = False):\n", + " block_name = \"bytenet_{}_layer_{}_{}\".format(block_type, layer_no, dilation)\n", + " print(block_name)\n", + " with tf.variable_scope(block_name, reuse = reuse):\n", + " relu1 = tf.nn.relu(layer_normalization(input_, block_name + '_0', reuse))\n", + " conv1 = conv1d(relu1, residual_channels, block_name + '_0', reuse)\n", + " relu2 = tf.nn.relu(layer_normalization(conv1, block_name + '_1', reuse))\n", + " dilated_conv = conv1d(relu2, residual_channels,\n", + " block_name + '_1', reuse,\n", + " dilation, filter_width,\n", + " causal = causal)\n", + " print(dilated_conv)\n", + " relu3 = tf.nn.relu(layer_normalization(dilated_conv, block_name + '_2', reuse))\n", + " conv2 = conv1d(relu3, 2 * residual_channels, block_name + '_2', reuse)\n", + " return input_ + conv2\n", + " \n", + "class ByteNet:\n", + " def __init__(self, from_vocab_size, to_vocab_size, channels, encoder_dilations,\n", + " decoder_dilations, encoder_filter_width, decoder_filter_width,\n", + " learning_rate = 0.001, beta1=0.5):\n", + " self.X = tf.placeholder(tf.int32, [None, None])\n", + " self.Y = tf.placeholder(tf.int32, [None, None])\n", + " self.X_seq_len = tf.count_nonzero(self.X, 1, dtype = tf.int32)\n", + " self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype = tf.int32)\n", + " batch_size = tf.shape(self.X)[0]\n", + " main = tf.strided_slice(self.Y, [0, 0], [batch_size, -1], [1, 1])\n", + " target_1 = tf.concat([tf.fill([batch_size, 1], GO), main], 1)\n", + " embedding_channels = 2 * channels\n", + " max_seq = tf.maximum(tf.reduce_max(self.Y_seq_len), tf.reduce_max(self.X_seq_len))\n", + " w_source_embedding = tf.Variable(tf.random_normal([from_vocab_size, \n", + " embedding_channels], stddev = 0.02))\n", + " w_target_embedding = tf.Variable(tf.random_normal([to_vocab_size, \n", + " embedding_channels], stddev = 0.02))\n", + " \n", + " def forward(x, y, reuse = False):\n", + " source_embedding = tf.nn.embedding_lookup(w_source_embedding, x)\n", + " target_1_embedding = tf.nn.embedding_lookup(w_target_embedding, y)\n", + " \n", + " \n", + " curr_input = source_embedding\n", + " for layer_no, dilation in enumerate(encoder_dilations):\n", + " curr_input = bytenet_residual_block(curr_input, dilation, \n", + " layer_no, channels, \n", + " encoder_filter_width,\n", + " 'encoder',\n", + " causal = False, reuse = reuse)\n", + " encoder_output = curr_input\n", + " combined_embedding = target_1_embedding + encoder_output\n", + " curr_input = combined_embedding\n", + " for layer_no, dilation in enumerate(decoder_dilations):\n", + " curr_input = bytenet_residual_block(curr_input, dilation, \n", + " layer_no, channels, \n", + " encoder_filter_width, \n", + " 'decoder',\n", + " causal = False, reuse = reuse)\n", + " with tf.variable_scope('logits', reuse = reuse):\n", + " return conv1d(curr_input, to_vocab_size, 'logits', reuse)\n", + " \n", + " self.logits = forward(self.X, target_1)\n", + " masks = tf.sequence_mask(self.Y_seq_len, max_seq, dtype=tf.float32)\n", + " self.cost = tf.contrib.seq2seq.sequence_loss(logits = self.logits,\n", + " targets = self.Y,\n", + " weights = masks)\n", + " self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(self.cost)\n", + " y_t = tf.argmax(self.logits,axis=2)\n", + " y_t = tf.cast(y_t, tf.int32)\n", + " self.prediction = tf.boolean_mask(y_t, masks)\n", + " mask_label = tf.boolean_mask(self.Y, masks)\n", + " correct_pred = tf.equal(self.prediction, mask_label)\n", + " correct_index = tf.cast(correct_pred, tf.float32)\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n", + " \n", + " def cond(i, y, temp):\n", + " return i < tf.reduce_max(max_seq)\n", + " \n", + " def body(i, y, temp):\n", + " logits = forward(self.X, y, reuse = True)\n", + " ids = tf.argmax(logits, -1)[:, i]\n", + " ids = tf.expand_dims(ids, -1)\n", + " temp = tf.concat([temp[:, 1:], ids], -1)\n", + " y = tf.concat([temp[:, -(i+1):], temp[:, :-(i+1)]], -1)\n", + " y = tf.reshape(y, [tf.shape(temp)[0], max_seq])\n", + " i += 1\n", + " return i, y, temp\n", + " \n", + " target = tf.fill([batch_size, max_seq], GO)\n", + " target = tf.cast(target, tf.int64)\n", + " self.target = target\n", + " \n", + " _, self.predicting_ids, _ = tf.while_loop(cond, body, \n", + " [tf.constant(0), target, target])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "residual_channels = 128\n", + "encoder_dilations = [1,2,4,8,16,1,2,4,8,16]\n", + "decoder_dilations = [1,2,4,8,16,1,2,4,8,16]\n", + "encoder_filter_width = 3\n", + "decoder_filter_width = 3\n", + "batch_size = 16\n", + "epoch = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bytenet_encoder_layer_0_1\n", + "WARNING:tensorflow:From :25: calling expand_dims (from tensorflow.python.ops.array_ops) with dim is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use the `axis` argument instead\n", + "Tensor(\"bytenet_encoder_layer_0_1/bytenet_encoder_layer_0_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_1_2\n", + "Tensor(\"bytenet_encoder_layer_1_2/bytenet_encoder_layer_1_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_2_4\n", + "Tensor(\"bytenet_encoder_layer_2_4/bytenet_encoder_layer_2_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_3_8\n", + "Tensor(\"bytenet_encoder_layer_3_8/bytenet_encoder_layer_3_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_4_16\n", + "Tensor(\"bytenet_encoder_layer_4_16/bytenet_encoder_layer_4_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_5_1\n", + "Tensor(\"bytenet_encoder_layer_5_1/bytenet_encoder_layer_5_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_6_2\n", + "Tensor(\"bytenet_encoder_layer_6_2/bytenet_encoder_layer_6_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_7_4\n", + "Tensor(\"bytenet_encoder_layer_7_4/bytenet_encoder_layer_7_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_8_8\n", + "Tensor(\"bytenet_encoder_layer_8_8/bytenet_encoder_layer_8_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_9_16\n", + "Tensor(\"bytenet_encoder_layer_9_16/bytenet_encoder_layer_9_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_0_1\n", + "Tensor(\"bytenet_decoder_layer_0_1/bytenet_decoder_layer_0_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_1_2\n", + "Tensor(\"bytenet_decoder_layer_1_2/bytenet_decoder_layer_1_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_2_4\n", + "Tensor(\"bytenet_decoder_layer_2_4/bytenet_decoder_layer_2_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_3_8\n", + "Tensor(\"bytenet_decoder_layer_3_8/bytenet_decoder_layer_3_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_4_16\n", + "Tensor(\"bytenet_decoder_layer_4_16/bytenet_decoder_layer_4_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_5_1\n", + "Tensor(\"bytenet_decoder_layer_5_1/bytenet_decoder_layer_5_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_6_2\n", + "Tensor(\"bytenet_decoder_layer_6_2/bytenet_decoder_layer_6_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_7_4\n", + "Tensor(\"bytenet_decoder_layer_7_4/bytenet_decoder_layer_7_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_8_8\n", + "Tensor(\"bytenet_decoder_layer_8_8/bytenet_decoder_layer_8_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_9_16\n", + "Tensor(\"bytenet_decoder_layer_9_16/bytenet_decoder_layer_9_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_0_1\n", + "Tensor(\"while/bytenet_encoder_layer_0_1/bytenet_encoder_layer_0_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_1_2\n", + "Tensor(\"while/bytenet_encoder_layer_1_2/bytenet_encoder_layer_1_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_2_4\n", + "Tensor(\"while/bytenet_encoder_layer_2_4/bytenet_encoder_layer_2_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_3_8\n", + "Tensor(\"while/bytenet_encoder_layer_3_8/bytenet_encoder_layer_3_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_4_16\n", + "Tensor(\"while/bytenet_encoder_layer_4_16/bytenet_encoder_layer_4_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_5_1\n", + "Tensor(\"while/bytenet_encoder_layer_5_1/bytenet_encoder_layer_5_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_6_2\n", + "Tensor(\"while/bytenet_encoder_layer_6_2/bytenet_encoder_layer_6_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_7_4\n", + "Tensor(\"while/bytenet_encoder_layer_7_4/bytenet_encoder_layer_7_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_8_8\n", + "Tensor(\"while/bytenet_encoder_layer_8_8/bytenet_encoder_layer_8_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_encoder_layer_9_16\n", + "Tensor(\"while/bytenet_encoder_layer_9_16/bytenet_encoder_layer_9_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_0_1\n", + "Tensor(\"while/bytenet_decoder_layer_0_1/bytenet_decoder_layer_0_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_1_2\n", + "Tensor(\"while/bytenet_decoder_layer_1_2/bytenet_decoder_layer_1_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_2_4\n", + "Tensor(\"while/bytenet_decoder_layer_2_4/bytenet_decoder_layer_2_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_3_8\n", + "Tensor(\"while/bytenet_decoder_layer_3_8/bytenet_decoder_layer_3_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_4_16\n", + "Tensor(\"while/bytenet_decoder_layer_4_16/bytenet_decoder_layer_4_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_5_1\n", + "Tensor(\"while/bytenet_decoder_layer_5_1/bytenet_decoder_layer_5_1_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_6_2\n", + "Tensor(\"while/bytenet_decoder_layer_6_2/bytenet_decoder_layer_6_2_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_7_4\n", + "Tensor(\"while/bytenet_decoder_layer_7_4/bytenet_decoder_layer_7_4_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_8_8\n", + "Tensor(\"while/bytenet_decoder_layer_8_8/bytenet_decoder_layer_8_8_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n", + "bytenet_decoder_layer_9_16\n", + "Tensor(\"while/bytenet_decoder_layer_9_16/bytenet_decoder_layer_9_16_1_1/Squeeze:0\", shape=(?, ?, 128), dtype=float32)\n" + ] + } + ], + "source": [ + "tf.reset_default_graph()\n", + "sess = tf.InteractiveSession()\n", + "model = ByteNet(len(dictionary_from), len(dictionary_to), \n", + " residual_channels, encoder_dilations, decoder_dilations,\n", + " encoder_filter_width,decoder_filter_width)\n", + "sess.run(tf.global_variables_initializer())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 1, avg loss: 6.328035, avg accuracy: 0.072276\n", + "epoch: 2, avg loss: 5.965444, avg accuracy: 0.094979\n", + "epoch: 3, avg loss: 5.767229, avg accuracy: 0.105403\n", + "epoch: 4, avg loss: 5.496558, avg accuracy: 0.143506\n", + "epoch: 5, avg loss: 5.061917, avg accuracy: 0.187899\n", + "epoch: 6, avg loss: 4.610906, avg accuracy: 0.227049\n", + "epoch: 7, avg loss: 4.046287, avg accuracy: 0.279907\n", + "epoch: 8, avg loss: 3.496574, avg accuracy: 0.345208\n", + "epoch: 9, avg loss: 2.976003, avg accuracy: 0.413868\n", + "epoch: 10, avg loss: 2.452929, avg accuracy: 0.501045\n", + "epoch: 11, avg loss: 1.891984, avg accuracy: 0.604314\n", + "epoch: 12, avg loss: 1.380336, avg accuracy: 0.710687\n", + "epoch: 13, avg loss: 1.001658, avg accuracy: 0.793238\n", + "epoch: 14, avg loss: 0.774593, avg accuracy: 0.842097\n", + "epoch: 15, avg loss: 0.455521, avg accuracy: 0.927808\n", + "epoch: 16, avg loss: 0.280280, avg accuracy: 0.970531\n", + "epoch: 17, avg loss: 0.159310, avg accuracy: 1.002358\n", + "epoch: 18, avg loss: 0.139503, avg accuracy: 1.003681\n", + "epoch: 19, avg loss: 0.063580, avg accuracy: 1.019896\n", + "epoch: 20, avg loss: 0.025332, avg accuracy: 1.023528\n" + ] + } + ], + "source": [ + "for i in range(epoch):\n", + " total_loss, total_accuracy = 0, 0\n", + " X, Y = shuffle(X, Y)\n", + " for k in range(0, len(text_to), batch_size):\n", + " index = min(k + batch_size, len(text_to))\n", + " batch_x, batch_y = pad_sentence_batch(X[k: index], Y[k: index], PAD)\n", + " predicted, accuracy, loss, _ = sess.run([tf.argmax(model.logits,2),\n", + " model.accuracy, model.cost, model.optimizer], \n", + " feed_dict={model.X:batch_x,\n", + " model.Y:batch_y})\n", + " total_loss += loss\n", + " total_accuracy += accuracy\n", + " total_loss /= (len(text_to) / batch_size)\n", + " total_accuracy /= (len(text_to) / batch_size)\n", + " print('epoch: %d, avg loss: %f, avg accuracy: %f'%(i+1, total_loss, total_accuracy))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 42)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predicted = sess.run(model.predicting_ids, \n", + " feed_dict={model.X:batch_x,model.Y:batch_y})\n", + "predicted.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "row 1\n", + "QUESTION: no , no , no . it 's four minutes long .\n", + "REAL ANSWER: không không không . nó chỉ dài bốn phút thôi .\n", + "PREDICTED ANSWER: không chỉ chỉ không được chỉ dài bốn phút mang đó pháp sử đi nếu ấy ngày hợp thao qua qua xấu hoặc trung tượng đi qua kiếm xấu qua rằng vấn tàu vấn rằng rằng thực thực đi chút tàu \n", + "\n", + "row 2\n", + "QUESTION: and you know , it was not a failure for ourselves in itself , but it was a failure that will impact his full life .\n", + "REAL ANSWER: và bạn biết đó , nó không phải là thất bại với chính bản thân chúng tôi mà là thất bại sẽ ảnh hưởng đến suốt đời mario .\n", + "PREDICTED ANSWER: khi nếu muốn đó thuật việc đề được tìm thất bại khí ý đồng đen đó toàn mà cũng thất tác chọn ảnh hưởng đến suốt đời " qua nói " ấy tối phê trung xa qua tài xấu giá lý \n", + "\n", + "row 3\n", + "QUESTION: but the choice was theirs , and our audience quickly grew to choose the richest and most varied diet that we could provide .\n", + "REAL ANSWER: nhưng sự lựa chọn thuộc về chúng , và khán thính giả của chúng tôi tăng lên nhanh chóng để chọn những món " ăn kiêng " giàu nhất và đa dạng nhất mà chúng tôi có thể cung cấp .\n", + "PREDICTED ANSWER: nhưng chiếc lựa chọn thuộc về chúng dành nên khán thính sát nhật nói 1 tăng lên tuần chóng nên chọn lên món " mạo truyền hoá xã đến qua đem luật yêu rwanda xa rằng giành xấu giá giá " \n", + "\n", + "row 4\n", + "QUESTION: a freshly waxed car , the water molecules slump to about 90 degrees .\n", + "REAL ANSWER: một xe vừa bôi sáp , những phân tử nước sụt xuống gần ̣ 90 độ .\n", + "PREDICTED ANSWER: từ xe vừa bôi sáp xét từ khô tử nước sụt xuống gần ̣ trị độ hoặc nguồn đến nguồn đến dụ qua đi qua yêu trung trở trung xuôi tàu qua xấu vấn tàu xấu qua thực hiểu dụng " \n", + "\n" + ] + } + ], + "source": [ + "for i in range(len(batch_x)):\n", + " print('row %d'%(i+1))\n", + " print('QUESTION:',' '.join([rev_dictionary_from[n] for n in batch_x[i] if n not in [0,1,2,3]]))\n", + " print('REAL ANSWER:',' '.join([rev_dictionary_to[n] for n in batch_y[i] if n not in[0,1,2,3]]))\n", + " print('PREDICTED ANSWER:',' '.join([rev_dictionary_to[n] for n in predicted[i] if n not in[0,1,2,3]]),'\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}