{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Jupyter companion notebook for the paper: \"Distributional analysis of polysemous function words\"\n", "# by Sebastian Pado and Daniel Hole\n", "# (c) Sebastian Pado, IMS, University of Stuttgart, 2020\n", "#" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from scipy import spatial\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.lines as mlines\n", "import itertools\n", "import statistics\n", "import pickle\n", "from sklearn.decomposition import PCA\n", "from matplotlib.markers import MarkerStyle\n", "from enum import Enum\n", "import torch\n", "from transformers import BertTokenizer, BertModel\n", "import pandas as pd\n", "import types\n", "import pkg_resources\n", "from sklearn.model_selection import cross_val_score, cross_val_predict\n", "from sklearn.svm import SVC" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# software versions:\n", "#jupyter --version\n", "#jupyter core : 4.6.1\n", "#jupyter-notebook : 6.0.2\n", "#qtconsole : not installed\n", "#ipython : 7.5.0\n", "#ipykernel : 5.1.1\n", "#jupyter client : 5.3.4\n", "#jupyter lab : not installed\n", "#nbconvert : 5.6.1\n", "#ipywidgets : 7.5.1\n", "#nbformat : 4.4.0\n", "#traitlets : 4.3.2\n", "#python --version\n", "#Python 2.7.17" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transformers==2.1.1\n", "torch==1.0.1.post2\n", "scipy==1.1.0\n", "scikit-learn==0.19.2\n", "pandas==0.25.3\n", "numpy==1.15.1\n", "matplotlib==2.2.3\n" ] } ], "source": [ "# list all versions of packages used here\n", "def get_imports():\n", " for name, val in globals().items():\n", " if isinstance(val, types.ModuleType):\n", " # Split ensures you get root package, \n", " # not just imported function\n", " name = val.__name__.split(\".\")[0]\n", "\n", " elif isinstance(val, type):\n", " name = val.__module__.split(\".\")[0]\n", "\n", " # Some packages are weird and have different\n", " # imported names vs. system/pip names. Unfortunately,\n", " # there is no systematic way to get pip names from\n", " # a package's imported name. You'll have to had\n", " # exceptions to this list manually!\n", " poorly_named_packages = {\n", " \"PIL\": \"Pillow\",\n", " \"sklearn\": \"scikit-learn\"\n", " }\n", " if name in poorly_named_packages.keys():\n", " name = poorly_named_packages[name]\n", "\n", " yield name\n", "imports = list(set(get_imports()))\n", "\n", "# The only way I found to get the version of the root package\n", "# from only the name of the package is to cross-check the names \n", "# of installed packages vs. imported packages\n", "requirements = []\n", "for m in pkg_resources.working_set:\n", " if m.project_name in imports and m.project_name!=\"pip\":\n", " requirements.append((m.project_name, m.version))\n", "\n", "for r in requirements:\n", " print(\"{}=={}\".format(*r))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# change this to your data directory, if you put the data files in a specific place\n", "data_dir = \"\"" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class Mode(Enum):\n", " phrase = 1\n", " sentence = 2\n", " \n", "## PARAMETERS\n", "\n", "experiments = [\n", "# experiments with other bert models, or 'deep' representation, not pursued / described in paper\n", " {'context': Mode.phrase, 'model': 'bert-base-german-cased', 'deep': False},\n", " {'context': Mode.sentence, 'model': 'bert-base-german-cased', 'deep': False},\n", "]\n", "\n", "anno_files = {\n", " Mode.phrase: data_dir+\"sich-phrase.dh.txt\",\n", " Mode.sentence: data_dir+\"sich-sentences.dh.txt\"\n", "}\n", "\n", "def exp2string(exp_desc):\n", " return exp_desc['context'].name+\"_\"+exp_desc['model']+\"_\"+str(exp_desc['deep'])\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# read annotations from file , and check sentences against model version\n", "# returns a dict that maps each idx onto the label for this data point\n", "def read_annotations(filename):\n", " labels = {}\n", " cleartext = {}\n", " idx = 0\n", " with open(filename, \"r\") as infile:\n", " for line in infile:\n", " idx = idx + 1\n", " tokens = line.rstrip().split(\" \")\n", " anno_label = tokens[0]\n", " sent = tokens[1:]\n", " # print str(len(sent)) + \" :: \"+str(len(internal_sent))\n", " # print(tokens)\n", "\n", " labels[idx] = anno_label\n", " cleartext[idx] = sent\n", " return labels, cleartext\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# compute embeddings of 'sich' for input sentences\n", "# use either final layer (\"shallow\"), or final and prefinal layer of transformer (\"deep\")\n", "\n", "def deep_embed(hidden_states, index):\n", " last_hidden_state = hidden_states[-1]\n", " prev_hidden_state = hidden_states[-2]\n", " vec1 = np.array(last_hidden_state[0][index])\n", " vec2 = np.array(prev_hidden_state[0][index])\n", " return np.concatenate((vec1, vec2))\n", "\n", "def shallow_embed(hidden_state, index):\n", " return np.array(hidden_state[0][index])\n", "\n", "def compute_embeddings(id2cleartext, tokenizer, model, exp):\n", " expid = exp2string(exp)\n", " id2vectors = {}\n", " for id,cleartext in id2cleartext[expid].items():\n", " bert_tokenized = tokenizer.tokenize(\"[CLS] \" + \" \".join(cleartext)+ \" [SEP]\")\n", "# print(bert_tokenized)\n", " if bert_tokenized.count(\"sich\") == 0:\n", " print (\"******* NO SICH in \"+str(id))\n", " elif bert_tokenized.count(\"sich\") > 1:\n", " print (\"******* MULTIPLE SICH in \"+str(id)+\", USING ONLY FIRST ONE\")\n", " sich_index = bert_tokenized.index(\"sich\")\n", " indexed_tokens = tokenizer.convert_tokens_to_ids(bert_tokenized)\n", " segments_ids = [0] * len(bert_tokenized) # build an array of length n with element 0\n", " tokens_tensor = torch.tensor([indexed_tokens])\n", " segments_tensors = torch.tensor([segments_ids])\n", " with torch.no_grad():\n", " if exp['deep']:\n", " _ , _, hidden_states = model(tokens_tensor, segments_tensors)\n", " sich_embed = deep_embed(hidden_states,sich_index)\n", " zeros = np.zeros(len(sich_embed)) \n", " embedding = sich_embed\n", " else:\n", " last_hidden_state, _ = model(tokens_tensor, segments_tensors)\n", " sich_embed = shallow_embed(last_hidden_state, sich_index)\n", " sich_l2 = np.linalg.norm(sich_embed)\n", " embedding = sich_embed\n", " id2vectors[id] = embedding\n", " return id2vectors\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# compute all pairwise cosine similarities among instances, aggregate and print\n", "\n", "def compute_sims(vectors, annotation, exemplars=False):\n", " label2ids = {label: [] for label in sorted(set(annotation.values()))}\n", " for id, label in annotation.items():\n", " label2ids[label].append(id)\n", " labels = label2ids.keys()\n", " for idx1, label1 in zip(range(len(labels)),labels):\n", " for idx2, label2 in zip(range(len(labels)),labels):\n", " if idx2 >= idx1:\n", " if exemplars:\n", " sims = [1-spatial.distance.cosine(vectors[x],vectors[y])\n", " for x,y in itertools.product(label2ids[label1],label2ids[label2])\n", " if x != y\n", " ]\n", " mean = round(statistics.mean(sims),3)\n", " sdv = round(statistics.stdev(sims),3)\n", " ssize = len(sims)\n", " print(\"Mean pairwise cos for \",label1,\" -- \",label2, \": mean \",mean,\", stdev \",sdv,\" #dp \",ssize)\n", " else:\n", " x_centroid = np.sum([vectors[id] for id in label2ids[label1]], axis=0)\n", " y_centroid = np.sum([vectors[id] for id in label2ids[label2]], axis=0)\n", " sim = 1-spatial.distance.cosine(x_centroid, y_centroid)\n", " print(\"Pairwise cos for \",label1,\" -- \",label2, \": \",sim)\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# plot sich embeddings in various ways, using PCA for reducing them to 2D\n", "# optionally save in PDF\n", "\n", "def plot(vectors, annotation, savefile = False, with_labels = False, drop_classes = [], show = False, extra_labels = \"\"):\n", " # dimensionality reduction\n", " all_vectors = [vectors[idx] for idx in sorted(vectors)] # sort in order of indices!\n", " M = np.array(all_vectors)\n", " reduced = PCA(n_components=2).fit_transform(M)\n", " # define marker styles\n", " labels = sorted(set(annotation.values()))\n", "# print(\"labels: \", labels)\n", " label2marker = {label: markerstyle for (markerstyle, label) in zip(MarkerStyle.filled_markers, labels)}\n", "# print (\"label2marker: \",label2marker)\n", " colors = ['orange', 'green', 'blue', 'grey', 'purple', 'olive', 'magenta', 'red']\n", " label2color = {label: color for label, color in zip(label2marker.keys(), colors)}\n", "# print (\"label2color: \",label2color)\n", " labels = sorted(set(labels) - set(drop_classes)) # skip unwanted labels\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " # plot first class 1, then class 2, ....\n", " # purpose: have the rarer classes come out \"on top\"\n", " for label in labels:\n", " for red_vec, idx in zip(reduced, sorted(vectors)):\n", " if label == annotation[idx]:\n", " if with_labels:\n", " ax.annotate(str(idx), xy=(red_vec[0], red_vec[1]),fontsize=3) \n", " plt.scatter(red_vec[0], red_vec[1], marker=label2marker[label], label=label, color=label2color[label]) # s=5: 5 point marker size\n", "\n", " handles = [\n", " mlines.Line2D([], [], marker=label2marker[label], linestyle='None', label=label, color=label2color[label]) for\n", " label in sorted(labels)]\n", " plt.legend(handles=handles)\n", " if savefile:\n", " if len(drop_classes) > 0:\n", " extra_labels = extra_labels + \"-drop\" + \"\".join(drop_classes)\n", " if not with_labels:\n", " extra_labels = extra_labels + \"-nolabels\"\n", " plt.savefig(savefile + \"-\" + extra_labels + \".pdf\")\n", " print(\"Saved figure as \"+savefile + \"-\" + extra_labels + \".pdf\")\n", " if show:\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# pickling & unpickling things (boilerplate)\n", "\n", "def store_obj(obj, filename):\n", " binary_file = open(filename,mode='wb')\n", " pickle.dump(obj, binary_file)\n", " binary_file.close()\n", "\n", "def read_obj(filename):\n", " return pickle.load( open(filename, mode='rb'))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# compute or read embeddings\n", "def get_vectors(compute_vectors, exp, id2cleartext):\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " bert_model_name = exp['model']\n", " deep = exp['deep']\n", " if compute_vectors:\n", " tokenizer = BertTokenizer.from_pretrained(bert_model_name, do_lower_case=False)\n", " if deep:\n", " model = BertModel.from_pretrained(bert_model_name, output_hidden_states=True)\n", " else:\n", " model = BertModel.from_pretrained(bert_model_name)\n", " model.eval()\n", " print(\" model \"+bert_model_name+\" initialized\")\n", " id2vectors = compute_embeddings(id2cleartext, tokenizer, model, exp)\n", " store_obj(id2vectors, expid+\".bin\")\n", " print(\" embeddings computed and stored\")\n", " else:\n", " id2vectors = read_obj(expid+\".bin\")\n", " print(\" embeddings read\")\n", " return id2vectors" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "## END OF DEFINITIONS\n", "## START OF MAIN PROGRAM\n", "\n", "# main stateful data structures: a bunch of nested dictionaries\n", "# each has the form: ID of experiment (exp2string) --> ID of observation (sentence) --> information\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reading annos for experiment phrase_bert-base-german-cased_False\n", "reading annos for experiment sentence_bert-base-german-cased_False\n", "finished\n" ] } ], "source": [ "# init data structures, read the manual annotation files\n", "\n", "id2annos = {}\n", "id2cleartext = {}\n", "id2sichvectors = {}\n", "\n", "for exp in experiments:\n", " print(\"reading annos for experiment \"+exp2string(exp))\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " model = exp['model']\n", " deep = exp['deep']\n", " id2annos[expid], id2cleartext[expid] = read_annotations(anno_files[context])\n", "print (\"finished\")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "computing vectors for experiment phrase_bert-base-german-cased_False\n", " model bert-base-german-cased initialized\n", "******* MULTIPLE SICH in 293, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 295, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 311, USING ONLY FIRST ONE\n", " embeddings computed and stored\n", "computing vectors for experiment sentence_bert-base-german-cased_False\n", " model bert-base-german-cased initialized\n", "******* MULTIPLE SICH in 293, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 295, USING ONLY FIRST ONE\n", "******* MULTIPLE SICH in 311, USING ONLY FIRST ONE\n", " embeddings computed and stored\n" ] } ], "source": [ "# now read and/or compute the embeddings\n", "# may involve downloading relatively larget BERT models through the Transformer library for local caching\n", "for exp in experiments:\n", " print(\"computing embeddings for experiment \"+exp2string(exp))\n", " expid = exp2string(exp)\n", " context = exp['context']\n", " model = exp['model']\n", " deep = exp['deep']\n", " # Can be changed to \"False\" once the embeddings have been computed once\n", " id2sichvectors[expid] = get_vectors(True, exp, id2cleartext)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT phrase_bert-base-german-cased_False\n", "Pairwise cos for 1 -- 1 : 1.0\n", "Pairwise cos for 1 -- 2 : 0.968328595161438\n", "Pairwise cos for 1 -- 3 : 0.9683874249458313\n", "Pairwise cos for 1 -- 4 : 0.9726495742797852\n", "Pairwise cos for 1 -- 5 : 0.9139770865440369\n", "Pairwise cos for 1 -- 6 : 0.8944994807243347\n", "Pairwise cos for 1 -- 7 : 0.9266935586929321\n", "Pairwise cos for 1 -- 8 : 0.8934210538864136\n", "Pairwise cos for 2 -- 2 : 1.0\n", "Pairwise cos for 2 -- 3 : 0.9422893524169922\n", "Pairwise cos for 2 -- 4 : 0.931257963180542\n", "Pairwise cos for 2 -- 5 : 0.8693873882293701\n", "Pairwise cos for 2 -- 6 : 0.8938131332397461\n", "Pairwise cos for 2 -- 7 : 0.9024670124053955\n", "Pairwise cos for 2 -- 8 : 0.8578556776046753\n", "Pairwise cos for 3 -- 3 : 1.0\n", "Pairwise cos for 3 -- 4 : 0.9545154571533203\n", "Pairwise cos for 3 -- 5 : 0.9051097631454468\n", "Pairwise cos for 3 -- 6 : 0.8665403127670288\n", "Pairwise cos for 3 -- 7 : 0.9071021676063538\n", "Pairwise cos for 3 -- 8 : 0.8863974809646606\n", "Pairwise cos for 4 -- 4 : 1.0\n", "Pairwise cos for 4 -- 5 : 0.9332249760627747\n", "Pairwise cos for 4 -- 6 : 0.862643301486969\n", "Pairwise cos for 4 -- 7 : 0.9081631898880005\n", "Pairwise cos for 4 -- 8 : 0.8947654366493225\n", "Pairwise cos for 5 -- 5 : 1.0\n", "Pairwise cos for 5 -- 6 : 0.8025975823402405\n", "Pairwise cos for 5 -- 7 : 0.8632334470748901\n", "Pairwise cos for 5 -- 8 : 0.8744102716445923\n", "Pairwise cos for 6 -- 6 : 1.0\n", "Pairwise cos for 6 -- 7 : 0.9214197993278503\n", "Pairwise cos for 6 -- 8 : 0.7778463363647461\n", "Pairwise cos for 7 -- 7 : 1.0\n", "Pairwise cos for 7 -- 8 : 0.8260442614555359\n", "Pairwise cos for 8 -- 8 : 1.0\n", "Saved figure as gb-sich-phrase-.pdf\n", "Saved figure as gb-sich-phrase--nolabels.pdf\n", "Saved figure as gb-sich-phrase--drop1.pdf\n", "Saved figure as gb-sich-phrase--drop1-nolabels.pdf\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# run first experiment (only)\n", "for exp in [experiments[0]]:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \"+expid)\n", " compute_sims(id2sichvectors[expid], id2annos[expid], exemplars = False)\n", " plot(id2sichvectors[expid], id2annos[expid], \"gb-sich\", with_labels = True,\n", " extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"gb-sich\" , with_labels = False,\n", " extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"gb-sich\" , with_labels = True,\n", " drop_classes = ['1'], extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"gb-sich\", with_labels = False,\n", " drop_classes = ['1'], extra_labels = \"phrase-\")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT sentence_bert-base-german-cased_False\n", "Pairwise cos for 1 -- 1 : 1.0\n", "Pairwise cos for 1 -- 2 : 0.9670372009277344\n", "Pairwise cos for 1 -- 3 : 0.9684858918190002\n", "Pairwise cos for 1 -- 4 : 0.9695988893508911\n", "Pairwise cos for 1 -- 5 : 0.9030987024307251\n", "Pairwise cos for 1 -- 6 : 0.8460327386856079\n", "Pairwise cos for 1 -- 7 : 0.9226700067520142\n", "Pairwise cos for 1 -- 8 : 0.8792943954467773\n", "Pairwise cos for 2 -- 2 : 1.0\n", "Pairwise cos for 2 -- 3 : 0.9407544732093811\n", "Pairwise cos for 2 -- 4 : 0.9262256026268005\n", "Pairwise cos for 2 -- 5 : 0.85330730676651\n", "Pairwise cos for 2 -- 6 : 0.8584476709365845\n", "Pairwise cos for 2 -- 7 : 0.902863621711731\n", "Pairwise cos for 2 -- 8 : 0.8349387049674988\n", "Pairwise cos for 3 -- 3 : 1.0\n", "Pairwise cos for 3 -- 4 : 0.9536876082420349\n", "Pairwise cos for 3 -- 5 : 0.8909614086151123\n", "Pairwise cos for 3 -- 6 : 0.8156458139419556\n", "Pairwise cos for 3 -- 7 : 0.9072516560554504\n", "Pairwise cos for 3 -- 8 : 0.8705460429191589\n", "Pairwise cos for 4 -- 4 : 1.0\n", "Pairwise cos for 4 -- 5 : 0.929846465587616\n", "Pairwise cos for 4 -- 6 : 0.7986355423927307\n", "Pairwise cos for 4 -- 7 : 0.9030077457427979\n", "Pairwise cos for 4 -- 8 : 0.8803982138633728\n", "Pairwise cos for 5 -- 5 : 1.0\n", "Pairwise cos for 5 -- 6 : 0.7450464367866516\n", "Pairwise cos for 5 -- 7 : 0.8517926335334778\n", "Pairwise cos for 5 -- 8 : 0.8678032755851746\n", "Pairwise cos for 6 -- 6 : 1.0\n", "Pairwise cos for 6 -- 7 : 0.8795211315155029\n", "Pairwise cos for 6 -- 8 : 0.7182119488716125\n", "Pairwise cos for 7 -- 7 : 1.0\n", "Pairwise cos for 7 -- 8 : 0.8134325742721558\n", "Pairwise cos for 8 -- 8 : 1.0\n", "Saved figure as mb-sich-phrase-.pdf\n", "Saved figure as mb-sich-phrase--nolabels.pdf\n", "Saved figure as mb-sich-phrase--drop1.pdf\n", "Saved figure as mb-sich-phrase--drop1-nolabels.pdf\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXtc1FX6+N9nbiIXxQvICCqKiYomKGkXRM1LrpqaWZuZW+Kt2t1sbX+7+91y29Ztr+WWba3mGrVddqt12yw1zRum6RoKpqYWXgFRUREHBIYZzu+PYXCGGa4zMMCct695wXzmfM55PgjnOed5nvM8QkqJQqFQKPwPja8FUCgUCoVvUApAoVAo/BSlABQKhcJPUQpAoVAo/BSlABQKhcJPUQpAoVAo/BSlABQKhcJPUQpAoVAo/BSlABQKhcJP0flagNro2rWrjI6O9rUYCoVC0WrYv3//JSllWH3atmgFEB0dTXp6uq/FUCgUilaDEOJMfdsqE5BCoVD4KUoBKBQKhZ+iFIBCoVD4KQ3yAQgh3gCmABellIMqr3UG3geigdPA/VLKAjf3Pgw8U/n2t1LKtxovtkJRf8rLy8nJyaG0tNTXotRIQEAAUVFR6PV6X4ui8CMa6gR+E/gr8A+Ha78Atkop/yCE+EXl+5873lSpJJ4FEgEJ7BdCrHOnKBQKb5OTk0NISAjR0dEIIXwtjgtSSi5fvkxOTg69e/f2tTgKP6JBJiAp5U7gSrXL0wD7av4tYLqbW+8CPpdSXqmc9D8HJjZQVoWiUZSWltKlS5cWOfkDCCHo0qVLi96hKNom3ggD7SalzKv8/jzQzU2bSCDb4X1O5TVFI4haHkWuKdflemRIJDlLcnwgUcunpU7+dlq6fIq2iVedwNJWX9KjGpNCiIVCiHQhRHp+fr6XJGtbTI2dikFrsL05C+wEfYWeabHTfCqXQqFoXXhDAVwQQhgBKr9edNMmF+jh8D6q8poLUsrXpZSJUsrEsLB6HWbzO5YmL0UjKv/rugIStELL0lFLfSqXomays7MZM2YMAwcOJC4ujpdfftnXIikUXjEBrQMeBv5Q+fVjN202Ab8TQnSqfD8B+D8vjO2XGEOMzI2fy5qMNZhzzGg7aJkWNo2I4Ahfi9bqSViVQOb5TJfr8RHxZCzKaHS/Op2OF198kaFDh2IymRg2bBjjx49n4MCBnoirUHhEg3YAQoh/AnuAWCFEjhBiHraJf7wQ4jtgXOV7hBCJQoi/A0gprwDLgK8qX7+pvKZoJFW7gH5guMXASw+/5GuR2gS3Rd12w7xWiUFr4Pao2z3q12g0MnToUABCQkIYMGAAubluN8EKRbPR0CigWVJKo5RSL6WMklKukVJellKOlVLeJKUcZ5/YpZTpUsr5Dve+IaXsW/lK9faD+Bv2XYBGaJgbP1et/r2Ek3mtEm+b106fPk1GRgYjRozwWp8KRWNQJ4FbMUuTlxIdGq1s/17ErljtuwCD1uBVBVtUVMS9997LSy+9RIcOHbzSp0LRWJQCaMUYQ4yceOKEWv17GcddgDdX/+Xl5dx7773Mnj2bGTNmeKVPhcITlAJQKKrRFOY1KSXz5s1jwIABLFmyxAtSKhSeoxSAQuGGpclLSeqZ5LXV/+7du3n77bfZtm0b8fHxxMfHs2HDBq/0rVA0lhZdEEah8BXGECNpj6R5rb+kpCRs5yQVipaD2gEoFAqFn6IUgEKhUPgpSgEoFAqFn6IUgEKhUPgpSgEoFAqFn6IUgEKhUPgpSgEoFM1AaWkpw4cPZ8iQIcTFxfHss8/6WiSFQikAhcIdeXkwahScP++d/tq1a8e2bds4ePAgmZmZfPbZZ+zdu9c7nSsUjUQpAIXCDcuWwa5dtq/eQAhBcHAwYMsJVF5erspAKnyOUgAKRTXy8iA1FSoqbF+9tQuwWq3Ex8cTHh7O+PHjVTpohc9RCkChqMayZbbJH8Bq9d4uQKvVkpmZSU5ODvv27ePw4cPe6VihaCRKASgUDthX/2az7b3Z7N1dAEBoaChjxozhs88+816nCkUjUApAoXDAcfVvxxu7gPz8fK5evQpASUkJn3/+Of379/esU4XCQ1Q2UIXCgT17bqz+7ZjN8OWXnvWbl5fHww8/jNVqpaKigvvvv58pU6Z41qlC4SFKASgUDmRkNE2/N998MxlN1blC0UiUCUihUCj8FI8VgBAiVgiR6fC6JoR4slqb0UKIQoc2v/J0XIVCoVB4hscmICnlcSAeQAihBXKBj9w0/UJKqYyentABMLm5HgJca2ZZFApFq8fbPoCxwAkp5Rkv96sAp8k/jTTOcIYIIgg1hXLlsytMnDjRd7IpFIpWh7d9AA8A/6zhs9uEEAeFEBuFEHE1dSCEWCiESBdCpOfn53tZvLZDAgl0pCMSSTHFvhZHoVC0QrymAIQQBmAq8KGbjw8AvaSUQ4BXgP/W1I+U8nUpZaKUMjEsLMxb4rU5XuEVMslEIMgmm4sXL/paJIVC0crwpgnoe8ABKeWF6h9IKa85fL9BCPGaEKKrlPKSF8f3K57maecLP/CNHIr6Y7VaSUxMJDIykk8//dTX4igUXjUBzaIG848QIkJUpj4UQgyvHPeyF8dWKJoEk8nE+vXrWbVqlcd9vfzyywwYMMALUikU3sErOwAhRBAwHljkcO1RACnlSmAm8JgQwgKUAA9IKaU3xm5KopZHkWvKdbkeGRJJzpKc5hcohJqjgBRexWQysXPnTjIzM5FSYrVaPeovJyeH9evX8/TTT7N8+XIvSalQeIZXFICUshjoUu3aSofv/wr81RtjNSdTY6eyJmMNZqsZTgNXQddRR0xQDGfPnqVnz57NK5AK9WxyvD3x23nyySf505/+hMnkToMrFL5BnQSuhaXJS9GIyh9RBBAAGjTMuX0OJSUlPpVN0TSsXbuW/fv3Y7FYvDb5f/rpp4SHhzNs2DCv9KdQeAulAGrBGGJkbvxcDFoD7APtBS0TYibQO6I3Z8+e9bV4iiZg5syZDBs2DJ1Oh1ar9Uqfu3fvZt26dURHR/PAAw+wbds2HnroIa/0rVB4gmjJpvjExESZnp7uUxnyTHn0WdGHUksp7XXtObn4JBHBEU0zmMNJ3zTSOMpRJjGJLwK+YOiBocqB2EiOHj3a4J9dUVERaWlpTqYgbxRy37FjBy+88ILbKKDGyKlQVEcIsV9KmViftiobaB3YdwGr9q9ibvxcp8nfxUl8BiiBrp268ufhf6Zv374kJSXVfzAH83ACCeSQQwklZJdmM6BETQzNSXBwMJMnT2bUqFGkpaWRk+MDp79C0cQoE1A9WJq8lOjQaJaOWup0fWrsVJt5yE4IaAu03Nb9Nrp3705xceNP6L7CK1ziEmc5SyyxZGdnN7ovReOxK4JFixbV3bgejB49Wp0BULQY1A6gHhhDjJx44oTL9aXJS0nNTL1x4RpoI7Sk3JJCbm4uN910U6PHdDnoNa3RXSkUCoVblALwALt5yB4qaogxMD9hPtPvmu5r0RSKVoWLOfU0UGozp/5f3/9jzpw5qNQw3keZgDzEMVRUK7QuZiKFQlE3LubUCNBesplTw8PDVdh1E9GmFUDU8ijEc8L2misQYwXiGUGn+ztx5ox3MlbbdwEaoXFxEjeYmk70qpO+ijaO05kbgH2gMWhIuSWF0NBQ5QNrItq0AnBaVUQARtBr9fTV9vXqiqImJ3GDuQZINy91AljRxnE6cwMYxhhY8PgCpt81nSlTpnDHHXf4WMK2SZtWAE6rin3AZdAUaHhk3CNePchldxI32fkAhcIPUObU5qdNO4GdnLTJZgxaA/MS5vHDyT/0tWgKPyQ6OpqQkBC0Wi06nQ5fH3JsadR25kbRNLRpBQDOoZptaVXhFDXxDXAJ20niixDaK5SC9wp8KF3rZVXCKqJuiyJ5aTIhRu87X7Zv307Xrl293m9bYWnyUjad2NRm/k5bOm1eAVRfVSS+ntiyUjw3kqmxU1m1fxUVsgKM2KorhAL5MDR8qI+la72czzxP/jf5ZKZmEj83vskUgcI9NZ25UTQNbV4BgPOqQiJvpHgGOA3aIi0jx45k8+bNXLhwgTlz5tSrX1/WC1iavJQ3Mt6gzFoGV7Ct/veDuCaYMHNCnfe3uFoHLQir2ZYFNGNNhlcVgRCCCRMmIIRg0aJFLFy40BviKhSNpk07ge04Omldws0iQBQK5g6aS1hYGMnJyfXq08UE8xmwCdgKIwNHevsRXDCGGElJSLE9SwwwBDT3anjs1cf4+ZM/r/N+l7jrb0C7X8udne7krbfeYsuWLU0nfCvBarZiKbWwf9V+1j6w1uP+du3axYEDB9i4cSOvvvoqO3fu9IKUCkXj8QsF4Ej1cDPtV1oSwhIouVzCmTNn6NWrV736cZpAjUBHoBhEqU2ZNAdLk5ei1+ir3hu0hnrbTl0UoRFEiWDhkIUUFxdjNpu9LW6rQ2vQomuvY9ijw5j5/kyP+4uMjAQgPDyce+65h3379nncp0LhCX6nAMB58jOMMbBu1TqmTZvG9On1T+HgNIFeAXKAb2F4wnBKLjfPqUX7LsBOSkJKvSMnqitCXaGO8beOp+RyCYGBgeh0fmEddIt94k+Yn8Dik4uZ/OpkgiOCPeqzuLi4qhpYcXExmzdvZtCgQd4QV6FoNH75V96QcDO3KZ/LoGtoV0aGjGRHyQ7KY8ohxhZl9N8l/23W8LWlyUvZ8N0GJLLBkROOEVL6vnreWPyG34feRcRHEHV7FKOWjvJ40nfkwoUL3HPPPQBYLBYefPBBJk6c6LX+FYrG4JcKAOofbuZUFxhsKZ8LtST3TiYpKIm042lVbefcPKfZJ1BjiJHTT55u9L0q7tqZRRneSftcnT59+nDw4MEm6VuhaCxeqwgmhDiNraSJFbBUr0gjhBDAy8Ak4DrwiJTyQG19+qIimNOK/zS2NAxGoBDQAgLEVsHWD7dycM9BdpTtYF3pOoINwXz7429bzSTq9JyVuxoMEFocSuafM+nVq5ero/siEAWhllA+nPch48aN843wDaS1VNpqLXIqWjYNqQjmbR/AGCllfA2Dfw+4qfK1EPibl8f2Ci75gwpBlAtEsIAKMMQYeOxvjzFmxBiefPJJ/vb43+jdqXermvyh2nOGANdBp9c55UlycXQHgE6j4+ZONysnsULRBmhOJ/A04B/Sxl4gVAhhbMbx64VL/iAr6Ip06K7rQOd6mtgeYpr4euKNzKPPCcQ9AjFP0GlmJ988SB04Pec1IB20wVqnPEkuju4A0AgNM26e4ddOYoWireBNBSCBzUKI/UIIdydcIgHHnK45lddaFE7RMclgGGtgwYMLmH//fDTRNad8domrDwKdQceY4WOaUfr64/Sc0WBYZGDe2Hn8cN4PmTBhgmubGDAMMzD/vvksfnRxVRuFQtF68aYCSJJSDsVm6vmhEKJ+J6qqIYRYKIRIF0Kk5+fne1G8+uMuK2FdKZ9d4uoDQGPS8PKClxs8vlMdg+8LxBiB+IGg0wOd2LVrV6OeqS6Za8qTpDI0KhRtF68pACllbuXXi8BHwPBqTXKBHg7voyqvVe/ndSllopQy0Vcl4NwVeakr5bNLPvNoA/NnzadHpxuP7DSxu3vdY5vsc9MdfixGIBB06EiKS/Ko0Hx9nrMxbRQKRevEKwpACBEkhAixfw9MAA5Xa7YO+IGwcStQKKXM88b43sQ+Sf8t/W9UyApe+/driHsF3X7ejY0bN7o9vu94j/mQGXaA+biZd997l82bN1e1czITHQYyQZwQaOz/DUG2L1qrlkg0LASGZUCPbyE4T9L5TGeOHDni1eetTzEbrxW88XOuXr3KzJkz6d+/PwMGDGDPnj2+Fknh53hrB9AN2CWEOIjNdbpeSvmZEOJRIcSjlW02ACeBLGA18LiXxvYqbmuTXtMyqvso4uLi0Ov1td9TuWIXUjAydqRTbiEnM5EF0NmiavTayj4DgFDoohPM02joDiQlQFxfmGSEiWOHExcX59XnrU8xG38reHPq1Haef749zz0neP759pw6td0r/S5evJiJEydy7NgxDh48qEI+FT7HKwpASnlSSjmk8hUnpXy+8vpKKeXKyu+llPKHUsoYKeVgKWWLqIZRvW7w3975G+bvzPA1NlW1D0SFYFK3SaxatQp3ZimXaBkJOp2OGTfNICAgoKqdk5lIB9oKLXfF3EVKQortWg+bo3XBkFA0FRZbd1cgIAA00sq2bS9gO06haCpOndrOP/85BYulFACLpZR//nOKx0qgsLCQnTt3Mm/ePAAMBgOhoaEey6tQeIJf5gJyxCXuP9+2eheBAnrZcgUtXLKQRx54hOeff56+ffu69FE9WoYRUN67nJRvU2xO3LGCyD9Gsnr1auZG2+zpDALDUAOrf7LaxdEa1v5G6GhMDMTHQ9++EB/fXkXfNDHvvTeJ8vLrTtfKy6/z3nuTPOr31KlThIWFMXfuXBISEpg/f75X/TkKRWPwewXgEvevB71Bj86qA339I19cooDsGEEbpGVKvylkZ2cTog1x62B2vBZgcJ93Xqdr78GTKuqDfeVf3+v179fCgQMHeOyxx8jIyCAoKIg//OEPHvWpUHiK35/mcVc3eH7CfCSSVftXoREajC+6nlfTCI2tGpedo0ABEA3aSC1WaSsqwhXQSA2zImeRez2Xs2fPus1D5FS0xnSON98cjdlsqvrcYAhh6tTVTfNDUFSh0wW4nex1ugA3retPVFQUUVFRjBgxAoCZM2cqBaDwOX6/A4Da4/5nDpzp7BQ+CtovtHQ/0935eiFoyjUEikAeuvmhG+Gg/QwseHQBo4ePZvbs2UyYMMGtU9XxmtE4lEce2UFExFC6dh1ARITtvdGoSj02NQ8+uAG9PtDpml4fyIMPbvCo34iICHr06MHx48cB2Lp1KwMHDvSoT4XCU/x+BwA1Z8U88cQJ8kx5vH/k/RuNC0HbW8tM40xWipU3rncBrVnLCyNeYPrY6VX3NPbwlNE4lEWL9nv0XIqG07v3GGbN+pT33puExVKKThfArFmf0ru35ye6X3nlFWbPno3ZbKZPnz6kpqZ6QWKFovEoBVBJTemhnUxEVjO6cB3xZfGMGjqKMn1Z1XVDf5vp6LHJjwG4KBSXLKOlQBl0Cu7El7/8kv79+3v9mVTd38bRu/cYnn7a+0V94uPjae7stgpFbSgTUCW1xbo7moj0/fR8/NrHTJ8+vdY0CdUPT7mLNtL30RPfOb7JnslpzO+AHaA7oWNa7LQmG1OhULQelAKoBzWlQ6gtTcItq2/hZMFJjC8ab5wStheVqcwyqg3UMto4mosXLzaJ3E6RSYGAzuanUCd6FQoF+JkJyMUkUlnkpEu/Lrx+1+vo9Xruvvtut/fWZCKq6bpTJbFM4CqIOIEIF1QkV2DQGkhJSOFXk3/l5ae8gZP5SpjRVmiZMHCC35zoVSgUteNXCsClvKMRtEVabou8ja5du3Lo0KEa77WbiGq6XlP1LC4CnQEt6KUejUZDqbW02TJrVtX97Q6GngZWL1ahpAqFwoZfmYBcDmtdAU2AhtlDZqPRaOjXr5/b+1yyeM6zne7tMq9LVRt31bOEEAijgHa2tA9ju4xlbkLzZtZU2TwVCkVN+JUCcEnZ3M/AgpQFPDDtAZKSkhg/frzb+1wSxHUFXW8dcYYbidncVc/SaXRor2oh0FZY5o2fveGTzJoqm6dCoXCHXykAaFyBE5edQ47tJPAPv/fDqkvuqmctuG8BCxYsQBPhvq6Ay87iPltNgG4/7+bVZ/a3bJ4tkePHjxMfH1/16tChAy+99JKvxVL4OX6nABpjEnHZOQwwMH/6fL4/9ftO7eqqJJaXB927p7FixVts3ryZ/nn90Z1ycMNYoEOhhimlZl59dSCrVg0jL++A9x5eUTcRgHDz8lB3xsbGkpmZSWZmJvv37ycwMJB77rnHU2kVCo/wOwUAjTOJ1LRzcFzFd5/fndI9pXDVtkOovuJftgzOn0/g3/8uwmKxkHJbCtpobdUYoToY2bGC6xevsmPHUT777ADPPJOklEBzcqGB1xvB1q1biYmJoVevXt7rVKFoBH6pABpjEqlp5+Di/C0BLHDfwPuc7s/Lg9RUkPIVvthdwuQ3ZjP7g9mUiTJb1NDHMLgMTFfg/Hlb+6tXobS0hHXrFnjnwRUtgn/961/MmjXL12IoFP6pABqLu52Di/M3HAxFBn4/7vdO9y5bBhUVAE+j0SxGk/17sBeEMgJhUGEGrRbat4eysspCMBqwWLyflkDhG8xmM+vWreO+++6ru7FC0cQoBdAAasri6eT8jTMwf+Z8pzb21b+58vhBhUVPxYEfgKnS2XsFOAVFRSCl7TVkCNx6q60QjKoD0HbYuHEjQ4cOpVs37zr6FYrG4FcHwdzhdIDrMpALtIPIxPonTKs6bIX7yKIbq/8baNDDF7+mYtJjtipiMXBFo2MaAk1FeVU7VQegbfHPf/5TmX8ULQa/3wE42fCvAVdAa9I2KGFaXZFF69bdWP3bqbDoqTg6xenaJY2emQ9+quoA+JKaFuZeWLAXFxfz+eefM2PGDM878yNMJhPr169n+fLlvhalzeH3OwDH1TuVpWC1XRuepqGmnEAAOZUbicfXP+6ciuI08DUEBQdRElPC3Pi5DI6ZwOAYVffXZ5xvuq6DgoK4fPly0w3QxjCZTOzcuZOPPvoIs9mMVqvlvffeo2vXrqo2tpfweAcghOghhNguhPhGCHFECLHYTZvRQohCIURm5avpMqA1ECcbfpztxG51G359+6krssjlQFkEcAVS+qQQHRrNf479x/lgWOUranlUI59OoWh92Ff8K1asICMjg7CwMEwmE1qtls6dO5OcnOxrEdsM3jABWYCnpJQDgVuBHwoh3NW6+0JKGV/5+o0XxvUa7mL8XU7pemEyrn6gTPuVlml3TePu2+/mxBMnuKf/PTfMUWeAb0GXrSM2O5Zdu3Z5+pgKRasgNTWV/fv3Y7FYsFqt7Nu3j2PHjhEYGEhpaSkBAZ7VZ1bcwGMFIKXMk1IeqPzehK08eqSn/TYn9olZFHVHLH+f//xjGzdfvfnGZHwZOAQGrcHjYiqOysYwxsDKH62sykHktEMIAa6DRqthwegFFBcXezSuQtFaSElJYdiwYeh0OrRaLcnJyTzwwAN06dKF6dOn+1q8NoVXncBCiGggAfifm49vE0IcFEJsFELEufncpyxNXkrwnj9yvWAgb76ZRVLHpBu2+mtAAJitZl5Lf61Bu4DqO4nuy7tTaikFcHEYO+0QroHYL7gv8T5KrpQQFBTkzcdVKFoswcHBTJ48mcWLF5OQkFClCBTex2tOYCFEMLAWeFJKea3axweAXlLKIiHEJOC/wE019LMQWAjQs2dPj2RyWwDmEnSO7szlNdWccUVGyvc/BHInGRnw1FO3EHc5jiP5R2zO4ZNAHujj9PQ626veW1GnGgSngaug7aAlaECQW4dxlVM6GgIWBfDCrBdUEjeFX2JXBKNGjSItLY3jx4/7WqQ2h1d2AEIIPbbJ/10p5X+qfy6lvCalLKr8fgOgF0J0ddeXlPJ1KWWilDIxLCzMI7lc0jgbXdM427kRq5+MRvMrdu4czzv3vGP7MA5IAgRorBqemvlUvWVwMutEAAE2P8PxHx13O7Gr/P0KhTN2RbBkyRJfi9Lm8EYUkADWAEellG4DdYUQEZXtEEIMrxy3yePh3BWA4TROaZzB9aSu2Wx7HyHiiQuLq7pXG6rlzs53ciX3CllZWU59OJl65trSOos5goELBzKe8TZFtA+0F7RMiKm9LKPK39/2+Mtf/kJcXByDBg1i1qxZlJaW+lokhcIrO4A7gDnAnQ5hnpOEEI8KIR6tbDMTOCyEOAisAB6QUkovjF0r7grALPzJQpc0zu5O6paYyzDe/arNBAQQA9bBVjJCM5g/fz6DBg1yau+026hc6es0Om7udDP3x95vU0TJtjDT1T+p/WSvyt/vY6xWeOEF6NoVXnzR9t4DcnNzWbFiBenp6Rw+fBir1cq//vUvLwmrUDQej30AUspd2DKm19bmr8BfPR2rMdSVpgHcn9TF2g6+nQ78yGa7Pw0iStBTuPdLOB0o2wdUgCXKws69O9mZsxOG2T5SZp0Wznffwf33274WF8Ozz8K778L778NNbt1W9cJisVBSUoJer+f69et0797di0IrFI2jzaeCqI9NPSfnRhI2++vctTwCftbX1iACiLSt6Bff43LOrWqcBTdNYRFwV1dICoLOOmAg0B30Gj0d2nVQZp2Wzh13wNdf2yZ/sH09eNB2vZFERkby05/+lJ49e2I0GunYsaM6yapoEbR5BQCNs6k7mY/2gfaclpFdRpJ3Mo/s7GyX9nl5B4jI2ogR6G+EvmEwWQtdAoBCm/KoyfHrSFMcQFM0gLg4V3tgRQVUM/k1hIKCAj7++GNOnTrFuXPnKC4u5p133vFQUIXCc/xCATTWpl7lRK603b/7m3d56qmn6NGjh0vbdesWUF5uWzVeuQKbNkFoINzbw5Yiur6mHydfwhkgE3SndB4fQFPUk3nzIDjY+VpwMKSkNLrLLVu20Lt3b8LCwtDr9cyYMYMvv/zSQ0EVCs/xCwXQWBoSkulYtCUmBhYtgi5dbE6W+hafBzengXWgQaNMR83F3XeDrpprTKezXW8kPXv2ZO/evVy/fh0pJVu3bmXAgAF136hQNDF+kw3Unlnw+PHjDYonri3LpyM1FW359hsouVbC4NzB5L+W7/K502G100A5oAeOYTuA1gEqtBV8/eXXRExQzuMmp2NHKCjwapcjRoxg5syZDB06FJ1OR0JCAgsXLvTqGIq2Q2PnqsbQ5hWAyWTi1Vdf5ejRo+j1ei5dusTw4cNJSkqq1/1281FdTJ26mjffHI3ZbKq6VgYcNIKuo47but/m/j7Hk8IR2Cb+LkA7IAgwwuiY0TRD1KyiCXnuued47rnnfC2GogVjMpn4/e9/z+HDhwkPD+fatWscOHCAoUObrh5ImzUBOaaULSoq4to1W3aKkJCQJkmsZjTaird0CR/MJQTngDeB/Cugua4h5Rb3NmQnk88+bAqgPba89JdBIzTM7D2TynN0CoWijeE5TsHTAAAgAElEQVQ4V5WVldGlSxcA2rVrh0bTtFN0m1UAjill9+zZU5VO1mQyNVliNaNxKD967GusiY/yptZAHrbDZ/NnzWf6Xe6zGDpFGyWDZpYGTVcNzAKmw5wZc1j08CIVNqhQtFEc56r8/Hw2bdpEYGAgVqsVq4eHEOtCtGTTQmJiokxPT2/UvUVFRaSlpZGZmYmU0ukH+eyzz3pLRLfkmfLos6IPpZZS2uvac3LxyVodyI7tA3QBSCkps5bV615F3Rw9epT+/fu36F2UlJJjx44p57Af4u25SgixX0qZWJ+2bXYH4IuUsvYY/u7Lu1OaVQo7oORoCQMeGcDu3btrvM8x2iglPoWUhBSVDM6LBAQEcPny5RbrR5FScvnyZVXoxE/xZfrrNu8Ebs6Usi4O3XLQaXXEBsXWea9jtJGUsl6RR4r6ERUVRU5ODvn5rlFYLYWAgACiotRhP3/GF+mv26wJyBc4mnLYCVSAvoue3yb/ltsSbmPkyJG+FlGhULRxGmICavM7gKbigw8+oKKiglOnTtGuXTuWLFlSZcpZk7EGc7IZ/fWe6P/+V670/ZpbFt7ia5EVCoXCCaUAGoHJZGLv3r0cOXIEo9FI7969qz5zzApaseNprhcMJDOzrN59Ox0M+wZbOcr2EGoI5ZMffVLv8wsKhUJRF0oBNAD7Cb3MzExyc3Pp3LmzS5yufRewcsfHkPkIyL1s23aFvXuzGD3aOaGYS8nK6hiBENCH6knqmKQKwysUCq/SZqOAmgLHeN2BAwfSv39/evXqBcD58zfa2QvMa9EDyQixkA8/dM0m6ZT47TTwNZAPfIktJcQV26s8pJyxXceqwvAKhcKrKCdwA6gpXvf06dPk5IxjxYqhHDp0CKs1lJSUCThW/WvfHk6ehAiHqE4np3Ep8BUQgy2HRBQ280829OrRi9MrTjfXYyoUilaMOgfgAXl5tmyejit6O9XjdbVaHRaLloiICHbsOEt2dgmhoaG8+650U2KyFGPSfMRYQeQfIwE3NQcqtGhMmqqVP9cAM/y/Ef+vqR9boVD4IUoBVGPZMjh16gNmz36LTz75xG0buyI4f34xmZkJfPHFQaQ089JL2RQUFLB3r3BTYjIAzs9DG6RlSr8pVZer1xyYc/8cDMMN0A24DsYORm4Ka3wpQoVCoagJv3cCr127lqysLCoqKjhy5CgffvhLpCxh584zjBtXVGMa+Lw8WLMmmNLSycBkAHbsgDfegEuXKts4mngAToCmQM+syFlV/dh3Aav2r2Ju/FyeSX6G94+8D4CIE3z26Gfc3O3mJnp6hULhz3hFAQghJgIvA1rg71LKP1T7vB3wD2yl0S8D35dSnvbG2J5gMpkoLCzk5MmTlJWVUVR0DZtLxJaPZ8+efjXeu2yZa+VAqxX63vsmxRPm2i6cwWbPNwDXQBeiY8GjCxg9fLTTfY6ngCOCI6oUwqPDHmXSu5NuRAqdBc4B3SDy5khyluR448egUCj8FI8VgBBCC7wKjAdygK+EEOuklN84NJsHFEgp+wohHgD+CHzf07Ebi2M4Z1ZWFqWlpbRv357S0lLKyy8C38dqhS1bbL6ACDfpeNatw8XMYzaD/vg0DN8z2NJBhAAF2NI7twddtM5teofqNQec0kIgb6SX6ApI0FWoEpEKRWtg7dq1ZGdn07FjRz766CM++OCDFpXzyRs7gOFAlpTyJIAQ4l/ANGzHmOxMA35d+f2/gb8KIYT0UQhSamoqV69eRUpJdHR01fVevXqxaVNy1fuAABN/+ctOunVzrcyTU8PiO89USp8Vla6Va0A6aGZoqCiqIOWWlHold3NUCI4Hy8gBNKAJUCUiFYqm5p133uHzzz9Hp9Nxyy23MGnSJHr27FnnffZJPzAwkE8++YTc3FxGjhxJ586dm0HqhuENBRAJZDu8zwFG1NRGSmkRQhRiq3t1yQvjN5iUlJQa068CBAebGDDgLwQEpHHoUBCBgcPq3bdTOohoM4ZFBmYNmsUXZ79o1KTt1F8/MwatgfkJ8+ulSNLS0sjIyGDLuS3EBsWynOXwHVAM6CDyNmVGUrQ98vIgKQl273a/ewfYtGkTmzZtori4mLFjxxIaGlpVc8PRQqDX68nLyyMsLIySkhL3nTlgMpm4dOkSn3zyCQMHDqSkpIQOHTpQUFDA1atXycrKYtAg1zNBvqLFOYGFEAuBhUC9tG1jqJ51z1ERfPrpejIzM8nJySMrS0NERNcG9++4atcKLX8Y94dGpXV2Oilc6U8wG8y8e+Rd7m1/L3feeWeN95pMJi5evMju3buJNkbTIaiD7YNA4CJoNVplRlK0SWyRfB9x770nWbNmMv3796/6zD65b9u2jdzcXAwGA6GhoUgpnSZ+KSUXL14kJyeHqKgoQkNDOXv2LLGx7jP7Ot57/PhxwsPDKSwspFOnTgQEBBATEwPQoiZ/8I4CyAV6OLyPqrzmrk2OEEIHdMTmDHZBSvk68DrYDoJ5Qb4aqa4I9u/fz/79+5FSUlFRQYcOHVxS9NanYHP1yJ7G5vR3Si9d6U8QgYKk/kmcPXvW7T2Ov4jbt29Hr9fT/mp7wrqE2RoI20vbRavMSIo2R14epKaClNmkp48gPx/698dlcr9y5QoVlVEcBQUFdOrUyck0DBATE1M1cY8dO7bWcR3vtd/TGvCGAvgKuEkI0RvbRP8A8GC1NuuAh4E9wExgm6/s/+5wtyPo0aMH3bt3r2pjMplYuXIlmzdvZsCAARQVFfHmmx8THd2R3bt38/TTTzv16ejIrQ2nVf5R4AIQB5F9IvlqwVc37P+V/gT9fXpmDZ5FTHf3v2SOv4jV008btAbM3c0YetTfjKRQtCZuROf1w2o9xR/+cJWRI/u7TO6Ovr/vf98Wj3L77bfXahqujdrMyjqdrsH9NRceHwSTUlqAHwGbsE1hH0gpjwghfiOEmFrZbA3QRQiRBSwBfuHpuE1BbZV5VqxYQUFBAVarlbKyMkJCQnj99W8pLy9n2DBXH4HdkVvXJOuUD6gQEKCTtigfp5PC0WBYZGD+2PnMnjGbW2+91W1/KSkpDBs2zG1VIXvxea1Qq39F28O++rdF503Eap3D9u1TOH++9r8LO55U5qrtXvu1kJAQLz2p91C5gGqhqKiIV155BXNlvOe339omfK1WS0BAAO+99wDvvx/IiRP7uP/+++nRo0cdPbridFjsO+A8GCIMnFl5hojgiAbXF3aUvfqK5ELiharzBa9OfrXBsioULZnHH4c1a5zDsw0GmD8fXq38dXf3d1FT3V1729rMvTXhyb2e0pBcQEoB1EFtBZt/97tnnX65quNk3jmN7SDXoG6I16fy6NyO3HbbzZSWlrJTt5MPcj/AbL0R5eM4QT++/vFGT9yOv4izFswiKTWJ3Sm7lflH0eaIioJcN9nVIyNdw7Z9OUE3NUoB1ILbgivdoMPFDhRuKKzxvqKiIjZuTOPgwUyEkOh0Vn7962fdZvm08/j6x284cUuBbBDHViD3RzN+/HVWr76VNWvWMG7aOO767K4aV/l5pjyvT9zLo5YTOzWW5KXJbP5yM7m5uXTq1ImzZ8+6+DMUCkXrQWUDrQUnm7sRiAQdOpJvTa71vuDgYLZvn8xrry3mwIEErl0LAd5Cr/8fCxb8jOXLl7vcU5XoDWAfcC4EmTkC+Ac7dlygXbtexMbGUnq5lLnxc9EIjduoofr6ExqCKddExpoMVvRZQeFHhQzsPZDk5GS3/gyFQtE28TsF4DQpXwGKQaPXMEw3jOzs7FrvXbcOCgqC2bBhMq+/voBbbjnN8OHPERJyAZPJ5NLeyYmbDJqiP6ERCcCHCPEEy5bB7NmzmTBhAkuTlxIdGt2szlmr2Yql1MIX73/BqntXcfiPhzmw50CdPweFQtE28DsF4DQpx4AhzsD86fP59S9/XacTNycHrl0z8emn6/nFL1YQH59LcHA7TKYrAIjnBOL7AjFWIB4UdHmkCyOKR9gUjimCioyHqbDoAZujKjX1Rt2Bpljl15doSzSDygexf9V+gt8JbpQzW6FQtD78TgGA8y6goSGRjmUhIyMjiY+PJzHRwdxmBHqC1qQleUAyRflFzI2fC2m/QlPt2IXVaotb9jVagxZdex3DHh1Gyu4UX4ujUCiaiRaXCqI5qPOkbgeg0qKzlrXkkksnOtE+oD1DPx9KYWFhzYdFrgA5oO2l5ZGERwgUgcy4dQavfyewVq7+7ZjN8PHHNUcRNTVagxahFcTPjWfU0lEERwT7RhCFQuET/FIBQB0ndR3M+cMYRvfKf8dLjxMcHExSUpLbPEIGrQFzjBlDP1so5/DB00hKgnfeyWLNy7sxGo1VCad8TUhkCLHTYtXE38KoHp11+PBh7rjjDq5evUqfPn0YOnSor0VsUrKysnjjjTcICAggODi4zYVotjT8VgFUz8FfE1lkcZ7zJJLIIQ5Vrfirp4/45tg3aEqdzUq/+RmcPg1//GM2KSmdkFK6Jng7A9wGHQ51IOvvWYSFhTXNA1djSY76w2opfPHFF3z++ecMGTKE3bm7+Xr112SmZmK810hIXAhms5kOHTqg0bRti63JZOLDDz8ktzKYv0+fPj6WqO3jtwqgvoxjXNX3U5hiq2nmQHBwMMnJthDS/3fw//G8eJ658XORpghSU215STZuvMSgQSdJTk5wTfDWBfRaPbfcdEu90s0q2hYmk4lvv/2W7777DiEE7WlPlCUKi8UWnXWJSxTdVUT/+/vTpUsXX4vbJDgmajt06BAXLlwgNDTU12L5BUoBeIDJZOLVV19l69at3H777ezetZvoadFVq/8bJSPvo6AAJkyAwabBzgneSkBToOHhkQ+TnZ3dZCmwFS0Lx0nv1KlTFBUVkZ+fjwULemy+omhLNNFEw0Y4f/Q895+437dCNxGOidoGDBjAgAEDfC2S36AUQCNw/OMtKSmhW7duWK1WjEYjW5/YWi0p1Y2Qz6VLwRhRrWBMjIF5CfOYM3mO60AOzug00jjKUSYxifOB57my9goTJ05stmdWeBfHSa9Hjx5Vobfd6FbVprqTvq1SV4EmRdPRto2KjaWmpH2V1x1DQTds2MChQ4c4ceIEmZmZvPfeezUWjLeHfNY7DNXBGZ1AAiGEUEIJxdeLG/9sihZBbdkp7WG5CfMTWHxyMZNfndymHfWeZOFUeIbf5QLyBvZEUhkZGRQXF7N582Y6duyI1WpFCMHRo3/j4kXXbaxjUqqH3/4F/1i8gNFzfsq48ERmzJjhuvUVN759kAcppJDHeZz/8l+6Pd2N3/72t034lIrmwCXZ4J+sJM5J9OvorLacqK05aEguIGUCagSOSnPfvn0EBgZy+fJlOnXqRGFhIRs3llBntF7aUrjani4XnkdrXFenA/h3/I7P+IyxjEWPHjmy5SpuRf2pHk12/NfHmbxksq/F8in2n8nkyf79c2gOlAmoEaSmppKeno7VaiU5ORmDwUDnzp0xGo3ExsbWmUsnLw8+eDcIpIZPPjpHUFBknfdkkYUFC1lkkUsuQUFB3nwkhY+xT3pqxatoTpQJqBFULxRTnZoKTNhxLFxRvWCFE8LNNTst979NoVD4EJUOuokJDg7mxz/+MUOGDEGI2mZpV2qKELInhQNs0T8O3a5lLStZyVnOspKVfKf/zuNnUPgvy6OWs/7x9ZjyTOzevZvnnnuOLVu2+FoshQ9QCqAG8vIgJgb+8580nn/+eUpLS1m5ciW7d+8GbEpg+vTpLFmypEGKoK4IIcAp+gds6Sguc5kSSkh7II0Vi1Z48GQKf8exFsTZNWcxF5lr3M0q2jbKCVwDy5bZ0jhs3JjAjBnXASgoKHBpZ1cE48aNq4pcsGOPFOrYsSPbt2/noYceYt26CVT/W6srKVwWWQxiEGc5y6BBgzh79qy3HlPhp1jNtlj7jW9v5BrXCDgWwMiEkYQYW17hckXToRSAG+xmmooKePPNV+jUKZgFCyK5++7LvPnmmwwbNoy3336bCRMm0KtXL8A1csFkMnHx4kV2795N9+7dkVIipXSpTVofHNNRjH96vFeeUaEAiLHEACA3SFKTUnnixBM+lkjRnHikAIQQfwbuBszACWCulPKqm3ansRk2rIClvg4KX+FoptFonmbDBptSMJkeZ/r0AwBkZ2dTMrAErrveb2lvYcXTK9i+fTt6vZ6CggJKS0uZ+M5E2GtrExkSSc6SRmgDhcKL+MtpY4V7PN0BfA78n5TSIoT4I/B/wM9raDtGSnnJw/GaHHdO2iNHbN9/+GEOQ4ZcISsri9jYWM5eP0t/+gM2R+1hDnMHdzCuZBwWi4WRI0c69f3v0/+GHaDrqSO2Syzbtm3jzjvvbManUyhsqFoQCvBQAUgpNzu83QvM9Ewc3+POSXuDZE6fTmbQIBg0aBA8dOOTYQzjAhcwY9McOp3ONa9JBFAOGjSkJKXUbMsPwcURXHW9EVTPMX/s2DFmzJjBgQMHGDp0qEq+5WeoWhAKO970AaQA79fwmQQ2CyEksEpK+boXx/Uq69bh4qS145jULaJaEbEssqigAl3lj3Tx4sVVR/zLreUIKWAfaKWWpPgkOrfvTKfundwPdM2zZ1i7di1BQUHs27ePvXv3MiJ3BBlrMqpyzFt6WigpKSE7O1tN/n6IqgWhsFOnAhBCbMG2dq3O01LKjyvbPA1YgHdr6CZJSpkrhAgHPhdCHJNS7qxhvIXAQsAnqZEdnbSOB7bs2EM2HSN23uIt+lT+m4Ct4pfjEf+NWzbyv4P/g2Qw6Ay8u/jdJiv+bjKZKCws5K233qJTp0507tzZJndl1McX73+BSZiwZFgYcN8AsrOzW0SVKcddiopEUSiahzoVgJRyXG2fCyEeAaYAY2UNx4qllLmVXy8KIT4ChgNuFUDl7uB1sJ0Erku+psTdbsBdyGY44QQRxAUuuPQRHBzMfdPvY7t+O5r9Grc1iO3ppT1JfuWYojorKwutVsu1a9e4fv064YTTkY6ALcc8gNgsuPTtJR488WCjxvM29tj0zNRMipOLCU0KxRhtJDAwkN69e7cIJaVQtDU8jQKaCPwMGCWldBMPA0KIIEAjpTRVfj8B+I0n4zYXtYVsmkwm2rdvj65ERyihfMqn3Mqttg/dLGDd1SA2mUysXLmSXbt2cdNNNxES0viVr2N++ejoaOcPHTw1LTnqw75LKdtexokdJwi7P4xuc7oRHKzs1ApFU+CpD+CvQDtsZh2AvVLKR4UQ3YG/SyknAd2Ajyo/1wHvSSk/83Bcn5OamsrVX1x1ygy6p/Kfu1xAjjWIHVfrxcXFXLt2jbKyMo8UQF1FNVpT1Ed+eT5FFHHm3TO8/cnbvH3kbV+LpFC0STyNAupbw/VzwKTK708CQzwZpyXiSRUjx9X6mTNniIqKorCwkK5duzZanupphR3lam1RH/0M/aqU1U+X/rRVyKxQtEZUNlAPcSnoYbXWmQ3U8Z7ycokQVjIzMykrK2PRokVMmzbNK3KtiF4BsfDjf//YybHqDZ+Dt3lOPNeqdiltAUfH+4FvD3D69GkiIyPJycmhb9++JCUl+VpERSNQBWGaEZeCHg65gOq6p3//UfzkJ2ncfHMmAQEhFBUVERAQ4B25ugfzS9Mv4Uugu62mcAklWA1WlictJyoqij59+nhlLG/Q2nYpbQFHx3u/2f241OcSYWFhdO/eneJiVXbUH1AKwEs0porRiy8Gs2nTZLZvH8WQISuJjNRRWlrqHYEcDpKlkUYWWWSTDWa4lHcJo9HonXG8hIpN9w12x/uqN1fRTrTj+sTrdL2zK4NvGexjyRTNgVIAPsIx5YTZHMzu3T+lfXt4+WXvj5VAAr/hNwxnOBIJWRAySsXaK24w0mpLWyI3SMq/KSfphDL/+ANKATQDeXmQlAS7d984QVxbXYCa0kI7kpaWxtatW0lISODUqVO12vJf4RV+xa8wYyaXXHKn5hJR/Sizwq9pyeHBiqZDKYAmwnHSX/YbSczJR/l51FtE3zWW7qGhnHvvQ/qRzGHWABeAK5jNE2utC2DHnmr6zJkzCCHQaGqv6/M0T1d9n0YaBaUFXL16ldOnT7NlyxbGjav1rJ+iDaMc7/6NUgBNxLJlcOrUWu4e/xX3HNlONzIosJaj37CRICRGoJN2B/++4wece+opygwGJk6svU/H8wP2VNNBQUF069at3nIlkEC7du2wWCyYzaoSlD+jHO8KpQCaALt9X8phJB/+GXGc5UMs5AM9kARhK6Bwk9XK2S+/JC8vD555ps5+Hc8PVE817UINGUX/ov0L169fp7CwEL1ej06nfgXqonqeorS0NI4ePcqkSZM4cuQIQUFBJCcnN/m43kY53hXqr78JuGHfzyKPcAyc4ntAGFSminOgogJGjYIf/KDOfh0Pnx0+fBiTycRNN93EuXPn+OSTT7j77rtvNHbIKOp47kArtdxqvbXqswkTXCRqclpb4jfHcMn4ufHEPxlPTk4OJSUlxMXFkZub2+Tjau/S0nt6b8xaM1JKoqKiVC0JhccoBVAL1fPo5+fnM2nSJI4ePUq7du0YPXq0yz3OBWXGkYeWO5hGB7cJ/oGgIJg9u17y2ENNhw0bxurVq9mxYwcWi4XAwMBa6wTXdkrYF1RP/MZguHPinWRlZTF48GDuuOMOn8hVG/ZwyYw1Gby0+iV6j+hN8I+C2XdoH3Pnzm3ycUs2lLBm/RpmPTCLDhM7qLrQCq+gFEAtOE5UxnuNnIs6R0lJCeHh4Vy65L64WfXoni+wmWpKaYcEAigDQBgMIITtVZc5xy6Pgw/g5MmThIeHU1hYiE6no1+/fnXe35hDa3SgypSURhq55BJCCOUB5eg/0DvvOhqAY+K377Z9h+GoAYbA4MEtO/7caraSRBJij+BM3hmeP/F8s4y7p3wPFVSQ/V4257ac45GPHmmWcRVtG6UA6sAxj365KOfDIx8S92AcXaOc8/bYdwuff5SM2XzDrGFFxyQ2MKZjBsuWASdsCeGIsRXjJiEBtNp6yVJbxs/x4+tfLL5Bh9YcNi4JJLCDHXSlK4NLB3Po7KF6j1kT+eX5WLBwcuNJyvaVMfZ7Yz3usynxVbjkGMMYhFYgNIKJd00krlccYCv+Y6/wtm/fPiIjI1VUl6LeKAVQT+x59Cs2VJD9TTb3nLjH6XP7buERTSbxj8VTmFhIr9heHDp0iEcffRTw/GCNJwnovMErvMJoRmPGjAZNvXYdddHP0I9YbWyLD0P0Vbhk9XFfNL7I4X8e5sj7R4ifG0/sI7F89913lJSUUFxcrKK6FA1CKYB6Up+Vn6OdeO/qvSRNTmLoI86FTNwdCqsvvrblO54nAKD+mw4XWlP8ua/CJWsa1/H37N9//zfXB1/n2yPfEhcfp6K6FA1C/bbUQWMmKqvZSiihpK9Lp93X7Zgw/Uakje18wAfMm9ee9esbZz9vlC2/BdHcE2p1Z35OTg5Dhgzh7Nmz9Yqm8VW4ZF3jWs1WoonmyoErFOYUMuWZKcTGxjaTdIq2gFIAteA4UckgSdrOtFpTKJ/mNFe5SogmhHJRzsC7BrJgzYKqz+0RQhPkR1zY2IsTB0eTc/UAu3bt4qmnnuLTTz+lT58+9S5/2JgEdC2B5p5Qqzvz474fR3l5OWFhYW0imsakMdHr5l4cyzimFICiQSgFUAtLcpZgMpn43e9/x1dffcXtt99OWloaJSUllJWVceHCBZKSkpgzZw4ARq2RUlmK7CsJTAik28huTitce4RQCBY6yGzeHrYCcZeFw4bDfPzxx7zwwgusXr262Z+zelz+2rVrOX78OJGRgynlCvYE1b3oxWhG2960/PB9J5yc+R+UM3jSYPre15f+/fv7WDLP6VXRC7FNcObkGXig/ve5+3+3hzp/8cUXDB06lAEDBjSd4AqfoxRADTiGXJaVldGuXTusVitBQUF88sknhIWFERkZydChQ1m/fj10gP91+B8VPSqIiolC6IWTk9TxfMAgBtkuWi1s2riJEkrY+u1WgjoG1cue74kfwe2zVjvoFPtILGFhYTzzzCF2CcGIEYVMnQrdE7t7ZPdvCdid+WWflJF7KJd7T9zrW4EaSEhkCKbcG6FZnkQluft/P3bsGCUlJWRnZ6vJ3w9QCqAGHEMu8/Pzqaio4MqVK3z77bf07duXTp06cfXqVbZu3crVq1dhCSTjnA5gwpcTiDwUSc6SHLfZPwFiZSyXuITuGx3t2rcjPDy8TtmWLYPTp+GRR9bStetHFBYWkpubS0pKCgMHDmzUCVEXx2KchcwjM5GygPT0c9xzTw+vFatpVqRkKOncyTa2cScH9cMROk2rzXq5JGeJV6unVf9/jxobxbEYmykpOzu73uZIRetEKYAacAy5jImJIaYybv+hhx5y2+6r/V9hlVZ06Dh79iwXLlxAF6Fj2j228o7r1tlPBzsTrY0mWkRDPHQb1Y0ePXrUKpd9JxEYaMJqLcRqrcBqtRIeHk5ISIjHNm27Y1FmCirYxr8JR4hnWL/+Te64o/asoy2OggJ46CHu4nP+RzkVbGSB8TxBm/5DcP/af84tmaZwotv/38VmwZlvz/DEiSe80q+iZaMUQA04Rtps2bKFr7/+Gnf1k0PmhoAOusqu3DbwNm6WNxPaNZSKigo0Wg1LRy0FICfnxj3PCRA6YSvOMhQYSb1t6s8/b2L8+J3cfHMmp05lce5cHhUVFURGRpKfn++1Oq75dGU7dwHZlJfDl18WcPmyV7puPu6+G776CgPlRAIXsNLt/Ncwfxbs2uVr6RpNUzjRc3Q5XBQXWbhgYavcGSkah0cKQAjxa2ABkF956ZdSyg1u2k0EXga0wN+llH/wZNzmJDg4mOnTpzNu3Di2bNlCxtcZWKUVgUCHDiygLdTyvVnfIzg8mNcOvEZMTgyabA33zbmPiGBXI719BZe4JJH0Y+n1jufPywOdLpWEhKtoNJJ+/aLp18AN+M4AAAlfSURBVC+66vOf/vSnjX5OrUFbZQ4A6MwVJrGaTNqTRSRm2ZnU1AqmTm30EM1PbCzs2QNADrasFlgsoGzbLtwUcxNTfjGFyY+0rogyhWd4YwfwFynlCzV9KITQAq9icx/mAF8JIdZJKb/xwtjNhl0RjBg7gsEvD2aEdQT96Q860IRo+NN9f0JKSWpmKun90mk/sD0fz/rYbV+OK7jJMfWP51+2DP71rxRuuy2NhIRMhJDodJ4fArMrpPTX0quu6bASQw96I7jKV6ywPsFXX3k8VPPy0EPw4YdgMt3wzjQg+Z4/cfjEYUofLUW3T9dqsrQqPKc5jLrDgSwp5UkppRn4FzCtGcZtEowhRu5PuJ8t2i0sZzmGIQYWpCwgIjgCY4iRufFz0QgNc+Pnul39u8NubqqtrCPY/AgFBcFs2DCZl19ezIEDCZSX67BY6pdLqCaW5Cxh8qvOKz+tQYuuvY7hjw/j+bwUpHQ2Y7UK7En22rW78WpA8j1/IsYSgyyT7F+1n9SkVF+Lo2gmvLED+JEQ4gdAOvCUlLKg2ueRQLbD+xxgRE2dCSEWAgsBevbs6QXxvM/S5KWkZtr+SLRCW2Xnt3+26cQmp2vewnkCDgYmU1Tk3dPArSlFQ53odLBhA2Rk3LjWgOR7/oSqCeyf1KkAhBBbAHdL2aeBvwHLAFn59UUgxROBpJSvA68DJCYmunpdWwD2lf6q/atcVvrGECMnnjjhtbHs5xFqOoHszdPAbbJEYFKS7aVwS5tS+IoGU6cCkFLWK7esEGI18Kmbj3IBx5i7qMprrZqmXOmDbeJ/7bXXOHLkCAaDgWvXrnHgwIEmjctWJQL9izap8BUNwtMoIKOUMq/y7T3AYTfNvgJuEkL0xjbxPwA86Mm4LQFvr/TtOJ5Avnz5MiaTiS5dutCuXTs0mlYWh69o0SiFr/B0RvmTEOKQEOJrYAzwEwAhRHchxAYAKaUF+BGwCTgKfCClPOLhuG2W1NRU9u/fj8VioaCggPT0dAIDA7FarT4r4ahQKNomwt3hppZCYmKiTE9Pr7thG8KxgHv1swHPPvusDyVTKBStASHEfillYn3aKptCC8Pu1F28eDEJCQnodDq0KmpFoVA0ASoVRAultRd9USgULR9lAlIoFIo2hDIBKRQKhaJOlAnIA6KWR5Frcj3SEBliqwHQVqleSUqhULROlALwgKmxU1mTsQaz1QzfAJdAn6QnNieWbdu2NaowS2vAsZKU9i4tYePDCO8Zjk6nIygoiOTk5Lo7USgUPkcpAA9wzAmEESi25QZKSUppFcXG3dWEzc3NpVOnTuTn5zNnzhzCwsLc3mtPHV2yoYTP139Ov9v68eMXf0yhpbA5H0GhUHiA8gF4gD0nkEFrgCugRcu0sGl0bt+5VRQbt6/kV/RZwfrH1xPbI5ZbbrmF5ORkwsPDKSkpqbOPPeV76GnpyfVd13lywpM1KgyFQtHyUDsAD6naBcSAIdbASw+/VO800C2B6jVhuyR34dm3nyU0NJTs7Ow6M7KOMYxRycQUilaKUgAeYt8FrNy8ktvl7fz52T8TGRlZZ27/lkZVTdjtgtSk1DprwqoskgpF60cpgP/f3v2EaFHHcRx/f1K6iFBhiu1GREjoxUXBky0qEtt6sC6VIBgGdsibF6FD0l4ikk4RVLh5yeoiSkSlItSxFrIMNhRZabfdFY2FFYRF/XaYWXbZntln1udZZ+aZzwse9jezw8yXH8PvO3+/0wZHthxh+PQwui60WUxPTxcdEpB8QnLr1p/Zv/8iu3Zto6+vL3PZpdSDdxVJs87gBNCC+ZU7195eyy1usXp1eR6LHBiAiYkuLl3aSNYDSQ9yJO8qkmadwQmgBYODg0xNTRERbCzZh8bHx2FwECJGuXjxDnv23GHhCYCP5M3qzQmgBQcPHsys3Fm0gQG4fx+gF6mXRqWEfCRvVm9+DLQFZa3cOXv0PzOTTM/MJNMTE8XGZWbl4gTQBgsTQdH3AeaO/ufcu5fMNzOb5WqgHai7G8YafHW5qwtGO7dEkZmxtGqgvgfQgTzIm1kevgRkZlZTTgBmZjXV0iUgSV8Dz6eTjwFTEdHTYLkRYBq4B9zNe33KzMyWT0sJICJem21LOg4sVgt4Z0TcbGV7ZmbWPm25CSxJwKtAZ34BxcysA7XrHsALwGREXMn4fwA/ShqSdKhN2zQzsxY0PQOQdB5oVOD+nYg4k7b3AacWWc32iBiTtBY4J2k4In7K2N4h4BDQtBa9mZk9uJZfBJO0EhgDtkZE0yfQJR0DbkfEh82W9YtgZmZL87BfBNsNDGcN/pJWAY9ExHTafhF4L8+Kh4aGbkq6DqwBfAO5OfdTfu6rfNxP+ZSpn57Ju2A7EsDrLLj8I+kp4POI6AfWAaeT+8SsBL6MiO/zrDginkzX96sfHW3O/ZSf+yof91M+Ve2nlhNARLzRYN4/QH/avgZsbnU7ZmbWXn4T2MyspqqSAD4tOoCKcD/l577Kx/2UTyX7qdTloM3MbPlU5QzAzMzarDIJQNIxSWOSfkt//UXHVCaS+iT9JemqpKNFx1NWkkYk/ZHuQ37JJCXphKQbki7Pm/eEpHOSrqR/Hy8yxrLI6KtKjk+VSQCpjyKiJ/19V3QwZSFpBfAx8BKwCdgnaVOxUZXaznQfqtxje8voC6BvwbyjwIWI2ABcSKetcV9BBcenqiUAa2wbcDUirkXEDPAVsLfgmKxC0tIs/y6YvRc4mbZPAi8/1KBKKqOvKqlqCeCwpN/TUzCfjs7pAv6eNz2azrP/c2HC/NZFxHjaniB5qdOyVW58KlUCkHRe0uUGv73AJ8BzQA8wDhwvNFirqu0RsYXkctnbknqLDqgKInlc0I8MZqvk+FSqj8JHxO48y0n6DPh2mcOpkjHg6XnT3ek8WyAixtK/NySdJrl81rAyrTEpaX1EjEtaD9woOqCyiojJ2XaVxqdSnQEsJt0BZ70CXM5atoZ+ATZIelbSoyT1mc4WHFPpSFolafVsm6QwofejbGeBA2n7AHBmkWVrrarjU6nOAJr4QFIPyWnoCPBWseGUR0TclXQY+AFYAZyIiD8LDquMHrgwYaeTdArYAayRNAq8C7wPfCPpTeA6yVf/ai+jr3ZUcXzym8BmZjVVmUtAZmbWXk4AZmY15QRgZlZTTgBmZjXlBGBmVlNOAGZmNeUEYGZWU04AZmY19R/goO3ekuso+QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# run second experiment (only)\n", "for exp in [experiments[1]]:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \"+expid)\n", " compute_sims(id2sichvectors[expid], id2annos[expid], exemplars = False)\n", " plot(id2sichvectors[expid], id2annos[expid], \"mb-sich\", with_labels = True,\n", " extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"mb-sich\" , with_labels = False,\n", " extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"mb-sich\" , with_labels = True,\n", " drop_classes = ['1'], extra_labels = \"phrase-\")\n", " plot(id2sichvectors[expid], id2annos[expid], \"mb-sich\", with_labels = False,\n", " drop_classes = ['1'], extra_labels = \"phrase-\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Classification experiments" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 1: full classification" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def confusion_matrix(yactu,ypred):\n", " pred = pd.Series(ypred, name = \"Predicted\")\n", " actu = pd.Series(yactu, name = \"Actual\")\n", " df_confusion = pd.crosstab(actu, pred)\n", " print(df_confusion)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT phrase_bert-base-german-cased_False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n", "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Freq baseline: 0.5402985074626866\n", "[0.61428571 0.60294118 0.58823529 0.70769231 0.71875 ]\n", "Accuracy: 0.6463808985132515\n", "Predicted 1 2 3 4 5 7\n", "Actual \n", "1 147 14 4 14 2 0\n", "2 27 32 2 3 1 0\n", "3 15 0 4 0 0 0\n", "4 20 4 0 11 0 0\n", "5 4 0 0 2 15 0\n", "6 1 0 0 0 0 2\n", "7 1 0 0 0 0 7\n", "8 3 0 0 0 0 0\n", "None\n", "EXPERIMENT sentence_bert-base-german-cased_False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n", "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Freq baseline: 0.5343283582089552\n", "[0.45714286 0.55714286 0.55882353 0.69230769 0.70967742]\n", "Accuracy: 0.595018871072002\n", "Predicted 1 2 3 4 5 7 8\n", "Actual \n", "1 136 20 6 14 3 0 0\n", "2 32 35 0 0 0 0 0\n", "3 14 2 1 2 0 0 0\n", "4 21 2 1 10 0 0 0\n", "5 5 0 0 4 12 0 1\n", "6 1 0 0 0 0 2 0\n", "7 0 2 0 2 0 4 0\n", "8 2 0 0 1 0 0 0\n", "None\n" ] } ], "source": [ "for exp in experiments:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \" + expid)\n", " X = np.array(list(id2sichvectors[expid].values()))\n", " Y = np.array(list(map(int, id2annos[expid].values())))\n", " clf = SVC(kernel='linear', C=0.1)\n", " scores = cross_val_score(clf, X, Y, cv=5)\n", " preds = cross_val_predict(clf, X, Y, cv=5)\n", " print(\"Freq baseline: \"+str(len([y for y in Y if y==1])/len(Y)))\n", " print(scores)\n", " print(\"Accuracy: \"+str(np.mean(scores)))\n", " print(confusion_matrix(Y, preds))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 2: and now without Class 1" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EXPERIMENT phrase_bert-base-german-cased_False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n", "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Freq baseline: 0.42207792207792205\n", "[0.72727273 0.625 0.8125 0.75862069 0.89285714]\n", "Accuracy: 0.7632501119570085\n", "Predicted 2 3 4 5 7\n", "Actual \n", "2 57 2 5 1 0\n", "3 1 10 7 1 0\n", "4 7 2 25 1 0\n", "5 0 1 3 17 0\n", "6 0 0 1 0 2\n", "7 0 0 0 0 8\n", "8 0 0 3 0 0\n", "None\n", "EXPERIMENT sentence_bert-base-german-cased_False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n", "/usr/local/lib/python3.7/site-packages/sklearn/model_selection/_split.py:605: Warning: The least populated class in y has only 3 members, which is too few. The minimum number of members in any class cannot be less than n_splits=5.\n", " % (min_groups, self.n_splits)), Warning)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Freq baseline: 0.42948717948717946\n", "[0.58823529 0.64705882 0.75 0.79310345 0.85185185]\n", "Accuracy: 0.7260498835549546\n", "Predicted 2 3 4 5 7 8\n", "Actual \n", "2 62 2 3 0 0 0\n", "3 6 7 5 1 0 0\n", "4 5 4 24 1 0 0\n", "5 0 1 5 15 0 1\n", "6 1 0 0 0 2 0\n", "7 2 0 2 0 4 0\n", "8 0 1 2 0 0 0\n", "None\n" ] } ], "source": [ "for exp in experiments:\n", " expid = exp2string(exp)\n", " print(\"EXPERIMENT \" + expid)\n", " X = np.array([vector for id, vector in id2sichvectors[expid].items() if id2annos[expid][id] != '1'])\n", " Y = np.array([int(cl) for id, cl in id2annos[expid].items() if cl != '1'])\n", " clf = SVC(kernel='linear', C=0.1)\n", " scores = cross_val_score(clf, X, Y, cv=5)\n", " preds = cross_val_predict(clf, X, Y, cv=5)\n", " print(\"Freq baseline: \"+str(len([y for y in Y if y==2])/len(Y)))\n", " print(scores)\n", " print(\"Accuracy: \"+str(np.mean(scores)))\n", " print(confusion_matrix(Y, preds))\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment 3: Prediction of features" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[{'membership': (x)>,\n", " 'name': 'predictable',\n", " 'excluded_classes': []},\n", " {'membership': (x)>,\n", " 'name': 'agentive',\n", " 'excluded_classes': [1, 3, 8]},\n", " {'membership': (x)>,\n", " 'name': 'stressable',\n", " 'excluded_classes': [8]},\n", " {'membership': (x)>,\n", " 'name': 'lassable',\n", " 'excluded_classes': []},\n", " {'membership': (x)>,\n", " 'name': 'disposition',\n", " 'excluded_classes': [1, 2, 8]}]" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# map class labels onto features; leave out classes for which features are underspecified (+-)\n", "\n", "properties = []\n", "\n", "def add_property(name, membership, exclude_classes):\n", " properties.append({'membership': membership,\n", " 'name': name,\n", " 'excluded_classes': exclude_classes})\n", "\n", "add_property(\"predictable\", lambda x: x in [1, 2, 3, 6, 7], [])\n", "add_property(\"agentive\", lambda x: x in [4,5,7], [1,3,8])\n", "add_property(\"stressable\", lambda x: x in [5], [8])\n", "add_property(\"lassable\", lambda x: x in [6, 7], [])\n", "add_property(\"disposition\", lambda x: x in [6], [1, 2, 8])\n", "\n", "properties" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PROPERTY predictable\n", " EXPERIMENT phrase_bert-base-german-cased_False, acc: 0.8566870441870442\n", " f: 276/335, freq BL: 0.8238805970149253\n", " EXPERIMENT sentence_bert-base-german-cased_False, acc: 0.8776276276276276\n", " f: 276/335, freq BL: 0.8238805970149253\n", "PROPERTY agentive\n", " EXPERIMENT phrase_bert-base-german-cased_False, acc: 0.8785725471771982\n", " f: 64/132, freq BL: 0.5151515151515151\n", " EXPERIMENT sentence_bert-base-german-cased_False, acc: 0.9176548089591567\n", " f: 64/134, freq BL: 0.5223880597014925\n", "PROPERTY stressable\n", " EXPERIMENT phrase_bert-base-german-cased_False, acc: 0.960906360906361\n", " f: 21/332, freq BL: 0.9367469879518072\n", " EXPERIMENT sentence_bert-base-german-cased_False, acc: 0.9700757575757576\n", " f: 22/332, freq BL: 0.9337349397590361\n", "PROPERTY lassable\n", " EXPERIMENT phrase_bert-base-german-cased_False, acc: 0.9970238095238096\n", " f: 11/335, freq BL: 0.9671641791044776\n", " EXPERIMENT sentence_bert-base-german-cased_False, acc: 0.985092235092235\n", " f: 11/335, freq BL: 0.9671641791044776\n", "PROPERTY disposition\n", " EXPERIMENT phrase_bert-base-german-cased_False, acc: 0.9651067323481116\n", " f: 3/86, freq BL: 0.9651162790697675\n", " EXPERIMENT sentence_bert-base-german-cased_False, acc: 0.9651067323481116\n", " f: 3/86, freq BL: 0.9651162790697675\n" ] } ], "source": [ "def f1(p,r):\n", " return 2*p*r/(p+r)\n", "\n", "for property in properties:\n", " print(\"PROPERTY \"+property[\"name\"])\n", " excluded_classes = property[\"excluded_classes\"]\n", " for exp in experiments:\n", " expid = exp2string(exp)\n", " X = np.array([id2sichvectors[expid][id] for id, cl in id2annos[expid].items() if not(int(cl) in excluded_classes)])\n", " Y = np.array([property[\"membership\"](int(cl)) for id, cl in id2annos[expid].items() if not(int(cl) in excluded_classes)])\n", " \n", " clf = SVC(kernel='linear', C=0.1)\n", "# scores = cross_val_score(clf, X, Y, cv=3, scoring = 'f1')\n", "# print(\" EXPERIMENT \" + expid + \", f1: \"+str(np.mean(scores)))\n", "# print(\" f: \"+str(sum(Y))+\"/\"+str(len(Y))+\", pred-1: \"+str(f1(sum(Y)/len(Y),1)))\n", " scores = cross_val_score(clf, X, Y, cv=3)\n", " print(\" EXPERIMENT \" + expid + \", acc: \"+str(np.mean(scores)))\n", " print(\" f: \"+str(sum(Y))+\"/\"+str(len(Y))+\", freq BL: \"+str(max(sum(Y)/len(Y),1-(sum(Y)/len(Y)))))\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.7.6" } }, "nbformat": 4, "nbformat_minor": 2 }