diff --git a/README.md b/README.md index c91f869a2dda5f2c56b78d9d7f2c61663b5813c7..2bee5bfed2c5aadacd72dac61fa3672287c3f4a4 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,18 @@ -# voeb-tm-tw +# VOEB Topic modelling (LV Th. Wallnig, WS 2021) + +## Preconditions + +Python packages: + +* pandas +* mathplotlib + + +* spacy 2.7 (current 3.1 does not work yet) (https://spacy.io) +* gensim < 4.0 (https://radimrehurek.com/gensim) + +For spacy you have to do `python -m spacy download de_core_news_sm` to retrieve +the trained data. + + -VOEB Topic modelling (LV Th. Wallnig, WS 2021) \ No newline at end of file diff --git a/tm_utils.py b/tm_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..42f138b4dd01763b2e59916092386daaf1a3448b --- /dev/null +++ b/tm_utils.py @@ -0,0 +1,282 @@ +# +# A module to bundle recurring functions for topic +# modelling +# +# working copy in jbekesi +# copy for all in /scratch, later on as package/wheel/lib + + +import datetime +import json +from pathlib import Path +from pprint import pprint +from operator import itemgetter +import subprocess +import shlex + +import gensim +import pandas as pd +import spacy + +import matplotlib.pyplot as plt + +# import nltk # do that later +from gensim import corpora +from gensim.utils import simple_preprocess +from gensim.models.coherencemodel import CoherenceModel + +# Initialize spacy 'de' model, keeping only tagger component (for efficiency) +# python3 -m spacy download en +# instead of this: +# nlp = spacy.load('de', disable=['parser', 'ner']) +# we use this: +try: + import de_core_news_sm + nlp = de_core_news_sm.load(disable=['parser', 'ner']) +except: + print("please load de_core_news_sm for lemmatization") + nlp = None + +NOW = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + +# search for stopwordfile +def get_stopwords(): + curpath = Path.cwd() + swf = "stopwords_de.txt" + for search in (".", ".."): + if curpath.joinpath(search, swf).is_file(): + return curpath.joinpath(search, swf).read_text().split("\n") + for search in curpath.iterdir(): + if search.is_dir() and search.joinpath(swf).is_file(): + return search.joinpath(swf).read_text().split("\n") + print("no stopword file {} found".format(swf)) + return [] + +# alternate stopword access +# nltk.download('stopwords') +# from nltk.corpus import stopwords +# stop_words = stopwords.words('german') + +# Build the bigram and trigram models + +#bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100) # higher threshold fewer phrases. +#trigram = gensim.models.Phrases(bigram[data_words], threshold=100) + +# Faster way to get a sentence clubbed as a trigram/bigram +#bigram_mod = gensim.models.phrases.Phraser(bigram) +#trigram_mod = gensim.models.phrases.Phraser(trigram) + +# Define functions for stopwords, bigrams, trigrams and lemmatization + + +def remove_stopwords(texts, include=[]): + stop_words = [] + stop_words = get_stopwords() + if include: + if type(include) == type([]): + stop_words += include + else: + print("include has to be type of 'list', skipping") + return [[word for word in simple_preprocess(str(doc)) if word not in stop_words] for doc in texts] + +def make_bi_trigrams(data_words): + bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100) # higher threshold fewer phrases. + trigram = gensim.models.Phrases(bigram[data_words], threshold=100) + # Faster way to get a sentence clubbed as a trigram/bigram + bigram_mod = gensim.models.phrases.Phraser(bigram) + trigram_mod = gensim.models.phrases.Phraser(trigram) + bigrams_out = [bigram_mod[doc] for doc in data_words] + trigrams_out = [trigram_mod[bigram_mod[doc]] for doc in data_words] + return bigrams_out, trigrams_out + + +def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']): + """https://spacy.io/api/annotation""" + texts_out = [] + for sent in texts: + doc = nlp(" ".join(sent)) + texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags]) + return texts_out + + +def save_lemmatized(data_lemmatized, corpusname="", datadir=None): + "if no corpusname or datadir save here for later use" + if not datadir: + datadir = Path.cwd() + if corpusname: + corpusname = "{}_".format(corpusname) + else: + print("no corpusname in saving lemmas, hope that's ok.") + filename = datadir.joinpath("lemmatized_{}{}.json".format(corpusname, NOW)) + with open(filename, 'w') as dlj: + json.dump(data_lemmatized, dlj) + + +def get_lemmatized(corpusname="", datadir=None): + "if no corpusname or datadir save here for later use" + if not datadir: + datadir = Path.cwd() + if corpusname: + corpusname = "{}_".format(corpusname) + else: + print("no corpusname in retrieving lemmas, hope that's ok.") + try: + print("corpusname:", corpusname) + filename = list(sorted(datadir.glob("lemmatized_{}*.json".format(corpusname))))[-1] + except Exception as err: + print("ERROR", err, datadir, corpusname) + return [] + with open(filename) as dlj: + return json.load(dlj) + + +def get_corpus_dictionary(data_lemmatized, corpusname="", save=True, + datadir=None, from_file=False): + "saving corpus for later use, returns dictionary and corpus" + if not datadir: + datadir = Path.cwd() + if corpusname: + orgcorpus = corpusname + corpusname = "{}_{}".format(corpusname, NOW) + else: + print("no corpusname in saving corpus/dictionary, hope that's ok.") + corpusname = NOW + + if from_file: + print(corpusname, orgcorpus) + # retrieve corpus from file, use last one + dictfile = str(sorted(datadir.glob("dict_{}*.dict".format(orgcorpus)))[-1]) + corpfile = str(sorted(datadir.glob("corpus_{}*.mm".format(orgcorpus)))[-1]) + id2word = corpora.Dictionary().load(dictfile) + corpus = corpora.MmCorpus(corpfile) + print("loading dict and corpus from {}, {}".format(dictfile, corpfile)) + return id2word, corpus + # OR: + # Create Dictionary + id2word = corpora.Dictionary(data_lemmatized) + # Create Corpus + # Term Document Frequency + corpus = [id2word.doc2bow(text) for text in data_lemmatized] + if save: + filename_dict = str(datadir.joinpath('dict_{}.dict'.format(corpusname))) + print(filename_dict) + id2word.save(filename_dict) # store the dictionary, for future reference + filename_corp = str(datadir.joinpath('corpus_{}.mm'.format(corpusname))) + corpora.MmCorpus.serialize(filename_corp, corpus) # save corpus in MarketMatrix format + print("saved dictionary and corpus in MarketMatrix format") + return id2word, corpus + +def csv_to_datasette(tablename="newTable", csv="", db=None): + # importing/overwriting csv data into/in datasette db + # csv has to be full path, e.g. str(Path.cwd().joinpath("foo")) + # trying to insert csv dominant_topic into datasette-db + # default for db name is login name of user + output_table = tablename + if not output_table: + print("no table name, skipping") + return + csvf = csv + if not db: + # try to use loginname as base for db + db = Path.home().stem.split("-")[-1] + cmd = 'csvs-to-sqlite -s ";" --replace-tables -t {} {} /opt/tljh/datasette/db/{}.db' + cmd = cmd.format(output_table, str(csvf), db) + args = shlex.split(cmd) + out = subprocess.run(args, stdout=subprocess.PIPE) + if out.returncode == 0: + print("Table {} in {}.db updated/created".format(output_table, db)) + else: + print("an error occurred, please revise!") + print(out) + + +def compute_coherence(corpus, id2word, texts, corpusname="noCorpusname", start=8, stop=33, step=4, + datadir=None, to_db=False): + # find optimal number of topics by computing coherence values + # %matplotlib inline + if not datadir: + print("no datadir given, stopping") + return + models = [] + print("computing coherence for the model starting with {}, " + "interval {} and stopping at {}".format(start, step, stop)) + for num_topics in range(start, stop, step): + print("computing lda num topics of", num_topics) + lda_model = gensim.models.LdaModel(corpus=corpus, + id2word=id2word, + num_topics=num_topics, + random_state=35009) + cm = CoherenceModel(model=lda_model, corpus=corpus, texts=texts, coherence="c_v") + models.append((num_topics, cm.get_coherence(), lda_model.show_topics(), cm, lda_model)) + + # Show graph + x = range(start, stop, step) + plt.plot(x, [m[1] for m in models]) + plt.xlabel("Num Topics") + plt.ylabel("LDA coherence score") + plt.legend(("coherence_values"), loc='best') + plt.show() + for m in models: + print("topics:", m[0], "coherence: ", m[1]) + + # comparison of topics: + # store it in a csv file for later perusal + + df = pd.DataFrame() + for m in models: + print("===", m[0]) + # print(m[2]) # what we did store earlier + for topic_num in range(m[0]): + wp = m[4].show_topic(topic_num) + topic_keywords = [word for word, prop in wp] + # print(" ", ", ".join(topic_keywords)) + df = df.append(pd.Series([int(m[0]), "t.{}".format(topic_num + 1)] + topic_keywords), ignore_index=True) + if not to_db: + return + df.columns = ['Number_topics', 'Topic_number'] + ["word_{}".format(x) for x in range(1,11)] + tablename = "lda_{}_coherence_topics_{}-{}.csv".format(corpusname,start,stop) + filename = str(datadir.joinpath("{}.csv".format(tablename))) + df.to_csv(filename, sep=";", index=False) + csv_to_datasette(tablename, filename) + print("Choosing a topic number for a model that marks the end of a rapid growth " + "of topic coherence usually offers meaningful and interpretable topics. " + "Picking an even higher value can sometimes provide more granular sub-topics.") + + +def format_topics_sentences(ldamodel=None, corpus=None, texts=None): + # cf. `testing_103.ipynb` + sent_topics_df = pd.DataFrame() + topics = {} + # Get main topic in each document + for i, row in enumerate(ldamodel[corpus]): + row_item = row[0] + print(row_item) + row_item = sorted(row_item, key=itemgetter(1), reverse=True)[0] + topic_num, prop_topic = row_item + if not topic_num in topics: + wp = ldamodel.show_topic(topic_num) + topic_keywords = ", ".join([word for word, prop in wp]) + topics[topic_num] = topic_keywords + else: + topic_keywords = topics[topic_num] + sent_topics_df = sent_topics_df.append(pd.Series([int(topic_num), round(prop_topic,4), + str(topic_num)+": " + topic_keywords]), ignore_index=True) + + sent_topics_df.columns = ['Dominant_Topic', 'Perc_Contribution', 'Topic_Keywords'] + contents = pd.Series(texts) + sent_topics_df = pd.concat([sent_topics_df, contents], axis=1) + sent_topics_df = sent_topics_df['Dominant_Topic'].fillna(0).apply(lambda x: str(int(x))) + return sent_topics_df + + +def convertldaGenToldaMallet(mallet_model): + """converts mallet model to gensim (for use in pyLDAvis) + (source: https://neptune.ai/blog/pyldavis-topic-modelling-exploration-tool-that-every-nlp-data-scientist-should-know) + """ + model_gensim = gensim.models.LdaModel( + id2word=mallet_model.id2word, num_topics=mallet_model.num_topics, + alpha=mallet_model.alpha, eta=0, + ) + model_gensim.state.sstats[...] = mallet_model.wordtopics + model_gensim.sync_state() + return model_gensim \ No newline at end of file diff --git a/voeb_tm_wallnig.ipynb b/voeb_tm_wallnig.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3469b7de9295daf0c81c4403a32de1967ad488a8 --- /dev/null +++ b/voeb_tm_wallnig.ipynb @@ -0,0 +1,992 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Topic Modelling on VOEB 1948-1973\n", + "\n", + "VOEB = Vereinigung Österreichischer Bibliotheken (Communications/Mitteilungen)\n", + "\n", + "Try to construct a time series with generated topic models from scanned volumes" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'data/export_job_1689308.zip'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_19468/2373056951.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdatadir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"data\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mdatafile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatadir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoinpath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'export_job_1689308.zip'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mzipfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZipFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdatafile\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmyzip\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mnamelist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmyzip\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnamelist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;31m# pprint(namelist)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/tljh/user/lib/python3.7/zipfile.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, file, mode, compression, allowZip64, compresslevel)\u001b[0m\n\u001b[1;32m 1202\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1203\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1204\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilemode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1205\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mOSError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1206\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfilemode\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodeDict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'data/export_job_1689308.zip'" + ] + } + ], + "source": [ + "# quick extraction from transkribus export (conducted locally)\n", + "# this will render an error, since data file is absent\n", + "\n", + "import zipfile\n", + "from pprint import pprint\n", + "from pathlib import Path\n", + "# datadir = Path('data-voeb')\n", + "datadir = Path(\"data\")\n", + "datafile = datadir.joinpath('export_job_1689308.zip')\n", + "with zipfile.ZipFile(datafile) as myzip:\n", + " namelist = myzip.namelist()\n", + " # pprint(namelist)\n", + " candidates = []\n", + " for f in namelist:\n", + " if f[7:].find('/') > -1:\n", + " continue\n", + " if f.endswith(\".txt\") or f.endswith(\".xml\"):\n", + " candidates.append(f)\n", + " pprint(candidates)\n", + " for c in candidates:\n", + " filename = c.split(\"/\")[-1]\n", + " with open(datadir.joinpath(filename), 'wb') as outf:\n", + " outf.write(myzip.read(c))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preparation and sectioning (into years / vols)\n", + "\n", + "This was done by manually inspecting each source file and inserting division markers like\n", + "`#### 1966-04 .3` (`.3` as volume number)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/tljh/user/lib/python3.7/site-packages/scipy/sparse/sparsetools.py:21: DeprecationWarning: `scipy.sparse.sparsetools` is deprecated!\n", + "scipy.sparse.sparsetools is a private module for scipy.sparse, and should not be used.\n", + " _deprecated()\n", + "/opt/tljh/user/lib/python3.7/site-packages/catalogue.py:138: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n", + " for entry_point in AVAILABLE_ENTRY_POINTS.get(self.entry_point_namespace, []):\n", + "/opt/tljh/user/lib/python3.7/site-packages/catalogue.py:138: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n", + " for entry_point in AVAILABLE_ENTRY_POINTS.get(self.entry_point_namespace, []):\n", + "/opt/tljh/user/lib/python3.7/site-packages/catalogue.py:126: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n", + " for entry_point in AVAILABLE_ENTRY_POINTS.get(self.entry_point_namespace, []):\n", + "/opt/tljh/user/lib/python3.7/site-packages/catalogue.py:138: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n", + " for entry_point in AVAILABLE_ENTRY_POINTS.get(self.entry_point_namespace, []):\n", + "/opt/tljh/user/lib/python3.7/site-packages/catalogue.py:138: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n", + " for entry_point in AVAILABLE_ENTRY_POINTS.get(self.entry_point_namespace, []):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "imports done\n" + ] + } + ], + "source": [ + "import re\n", + "import sys\n", + "import datetime\n", + "from pprint import pprint\n", + "from pathlib import Path\n", + "\n", + "import gensim\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "sys.path = [\"/scratch/\"] + sys.path # tm_utils.py reside in `/scratch` directory\n", + "import tm_utils # but we import it from current dir\n", + "\n", + "# mapping for splitter and dividing into years, vols...\n", + "DATASRC = Path(\"data-tw-src\")\n", + "DATA = Path(\"data-tw\")\n", + "mapping = {}\n", + "corpusname = \"voeb48-73\"\n", + "print(\"imports done\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "processed 27 files from data-tw-src into 112 volumes\n", + "2021-10-28T17:54:38.906933\n" + ] + } + ], + "source": [ + "number_re = re.compile(r'\\s+\\d+\\s+') # remove numbers from text\n", + "# #### 1973-03 .1\n", + "split_re = re.compile(r'\\#\\#\\#\\# (?P<year>\\d{4})-(?P<month>\\d{2}) *\\.*(?P<vol>\\S*)')\n", + "files = DATASRC.glob(\"*.txt\")\n", + "\n", + "df = pd.DataFrame()\n", + "data = []\n", + "headers = ['year', 'month', 'vol', 'text', 'filename']\n", + "for idx, f in enumerate(sorted(files)):\n", + " tmp = []\n", + " filename = f.stem\n", + " # print(filename)\n", + " cont = f.read_text()\n", + " first = True\n", + " for m in split_re.finditer(cont):\n", + " span = m.span()\n", + " if first:\n", + " prev_end = span[1]\n", + " this_start = span[0]\n", + " if not first:\n", + " text = cont[prev_end:this_start]\n", + " prev_end = span[1]\n", + " tmp = [year, month, vol, text, filename]\n", + " data.append(tmp)\n", + " month = m.group('month')\n", + " year = m.group('year')\n", + " vol = m.group('vol')\n", + " # print(year, month, span)\n", + " first = False \n", + " data.append([year, month, vol, cont[prev_end:], filename])\n", + "print(f\"processed {idx+1} files from {DATASRC} into {len(data)} volumes\")\n", + "df = pd.DataFrame(data, columns=headers) \n", + "df.to_csv(str(DATA.joinpath(\"voeb_48-73.csv\")), sep=\";\", quoting=2, index=False) \n", + "print(datetime.datetime.now().isoformat())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lemmata, Corpus, Dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['scnftfalen', 'vereinigung', 'bibliothekare', 'herausgegeben', 'auftrage', 'vorstandes', 'vereinigung', 'bibliothekare', 'vereinigung', 'bibliothe', 'sommer', 'sommer', 'genaues', 'verzeichnis', 'artikel', 'mitteilungen', 'jahres', 'mitteilungen', 'witteilungen', 'seilagen']\n" + ] + } + ], + "source": [ + "data_words = []\n", + "documents = [x[3] for x in data]\n", + "for text in documents:\n", + " data_words.append(list(\n", + " gensim.utils.simple_preprocess(\n", + " text, deacc=True, min_len=5)\n", + " ))\n", + "print(data_words[0][:20])\n", + "add_stopword = [\"bibliothekar\", \"bibliothekare\",\n", + " \"bibliothek\", \"bibliotheken\"]\n", + "data_words = tm_utils.remove_stopwords(data_words, include=add_stopword)\n", + "\n", + "# bigrams:\n", + "\n", + "data_words_bigrams, data_words_trigrams = tm_utils.make_bi_trigrams(data_words)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# lemmatization\n", + "corpusname = \"voeb48-73\"\n", + "data_lemmatized = tm_utils.lemmatization(data_words_bigrams)\n", + "save_lemmatized = tm_utils.save_lemmatized(data_lemmatized, corpusname=corpusname,\n", + " datadir=DATA)\n", + "# cnotify(\"Lemmatization done\")\n", + "print(\"done\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "data-tw/dict_voeb48-73_20211028-175146.dict\n", + "saved dictionary and corpus in MarketMatrix format\n" + ] + } + ], + "source": [ + "idword, dictionary = tm_utils.get_corpus_dictionary(data_lemmatized, \n", + " corpusname=corpusname, save=True, \n", + " datadir=DATA, from_file=False)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "computing coherence for the model starting with 8, interval 2 and stopping at 30\n", + "computing lda num topics of 8\n", + "computing lda num topics of 10\n", + "computing lda num topics of 12\n", + "computing lda num topics of 14\n", + "computing lda num topics of 16\n", + "computing lda num topics of 18\n", + "computing lda num topics of 20\n", + "computing lda num topics of 22\n", + "computing lda num topics of 24\n", + "computing lda num topics of 26\n", + "computing lda num topics of 28\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEGCAYAAACtqQjWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+9UlEQVR4nO3dd3xV9fnA8c+TDSGsEGYYAcIICAgRUHGigBOoVaGg1lHFuupo1VqtrbW1jtb+qtZSpY4iiANFRcWtqIyArACBsMMMIBBG9vP745zoJWTchHtz7k2e9+t1X7n3zOdeLnlyznPO9xFVxRhjjAmECK8DMMYYU39YUjHGGBMwllSMMcYEjCUVY4wxAWNJxRhjTMBEeR2Al1q1aqVdunTxOgxjjAkrixYt2q2qSRXNa9BJpUuXLmRkZHgdhjHGhBUR2VTZPDv9ZYwxJmAsqRhjjAkYSyrGGGMCpkHXVIwxxktFRUXk5OSQn5/vdSgViouLIzk5mejoaL/XsaRijDEeycnJISEhgS5duiAiXodzFFVlz5495OTkkJKS4vd6dvrLGGM8kp+fT2JiYsglFAARITExscZHUUFNKiIySkSyRCRbRO6pYP5oEVkmIktEJENEhvnMu01EVohIpoj8ymd6SxH5SETWuj9b+My7191XloiMDOZ7M8aYQAjFhFKmNrEFLamISCTwNHAekAaMF5G0cot9AvRX1QHANcBz7rp9gV8Ag4H+wIUikuqucw/wiaqmuuvf466TBowD+gCjgGfcGAJu76FCHpyVyf4jRcHYvDHGhK1gHqkMBrJVdb2qFgLTgdG+C6jqQf2xoUs8UPa8NzBPVQ+rajHwBTDWnTcaeNF9/iIwxmf6dFUtUNUNQLYbQ8Bt23eEl77dyBNzsoKxeWOMCVvBTCodgC0+r3PcaUcRkbEishp4D+doBWAFcLqIJIpIY+B8oKM7r42qbgdwf7au4f6ud0+1ZeTm5tbqjfXt0IwrT+7Cy/M2sTxnf622YYwx9VEwk0pFJ+OOaTOpqjNVtRfOEcdD7rRVwF+Bj4APgKVAcYD2N1lV01U1PSmpwqFr/HLHiB4kxsfyu7eWU1Jq3TONMeHppZdeol+/fvTv358rrrjiuLcXzEuKc/jx6AIgGdhW2cKq+qWIdBORVqq6W1WfB54HEJE/u9sD2Cki7VR1u4i0A3bVZn/Hq2lcNPdf2Jvbpi9h2oLNTBzaOVi7MsY0AH94J5OV2w4EdJtp7Zvy+4v6VDo/MzOThx9+mK+//ppWrVqxd+/e495nMI9UFgKpIpIiIjE4RfRZvguISHdxLy8QkYFADLDHfd3a/dkJ+AkwzV1tFnCV+/wq4G2f6eNEJFZEUoBUYEGQ3hsAF/dvz8ldE3n0g9XsPlgQzF0ZY0zAffrpp/z0pz+lVatWALRs2fK4txm0IxVVLRaRm4EPgUhgiqpmisgkd/6zwCXAlSJSBBwBLvcp3L8hIolAEXCTqn7vTn8EmCEi1wKbgUvd7WWKyAxgJc6psptUtSRY7w+cy+0eGtOX8/7xJX+evYq/XTYgmLszxtRjVR1RBIuqBvySZvnxd3jDk56eroEY+v6xD1fz9GfrmH79UIZ2TQxAZMaYhmDVqlX07t3bs/1nZmYyduxYvv32WxITE9m7d+8xRysVxSgii1Q1vaJt2h31AXDzWal0aN6I+99aQVFJqdfhGGOMX/r06cN9993HGWecQf/+/bnjjjuOe5uWVAKgUUwkf7i4D2t3HWTK3A1eh2OMMX676qqrWLFiBUuXLuWFF1447u1ZUgmQc9LacE7vNjz58Vq27TvidTjGGOMJSyoB9PuL0lCUP76z0utQjDHGE5ZUAqhjy8bccnYqH2Tu4LPVu6pfwRjT4IXyxVK1ic2SSoD94rSudEuK54FZK8gvCuoVzcaYMBcXF8eePXtCMrGU9VOJi4ur0XrWpCvAYqIieGhMX372n/k881k2d4zo6XVIxpgQlZycTE5ODrUdhzDYyjo/1oQllSA4pVsrxgxoz7NfrGfMiR3omtTE65CMMSEoOjq6Rl0Vw4Gd/gqS317Qm9ioCB54OzMkD22NMSYYLKkESeuEOO4a2ZO52bt5b/l2r8Mxxpg6YUkliCYO7Uyf9k354zsrycu3LpHGmPrPkkoQRUYID489gdyDBfz9o7Veh2OMMUFnSSXIBnRszs8Gd+KFbzaQuc26RBpj6jdLKnXgNyN70aJxDPe/tYJS6xJpjKnHLKnUgWaNo7n3/N4s3ryP1xZt8TocY4wJGksqdeSSgR0Y3KUlf3l/NXsPFXodjjHGBEVQk4qIjBKRLBHJFpF7Kpg/WkSWicgSEckQkWE+824XkUwRWSEi00Qkzp3+qrv8EhHZKCJL3OldROSIz7xng/neaqqsS2RefjGPfrDa63CMMSYogpZURCQSeBo4D0gDxotIWrnFPgH6q+oA4BrgOXfdDsCtQLqq9sVpRzwOQFUvV9UB7jpvAG/6bG9d2TxVnRSs91ZbPdsmcO2wFKYv3MKiTXu9DscYYwIumEcqg4FsVV2vqoXAdGC07wKqetCnJ3084FvFjgIaiUgU0BjY5ruuOI2VLwOmBSn+oLhteCrtmsVx38wVFFuXSGNMPRPMpNIB8K1K57jTjiIiY0VkNfAeztEKqroVeBzYDGwH9qvqnHKrngbsVFXfG0BSROQ7EflCRE6rKCgRud491ZbhxSBu8bFR/P6iNFbvyOPFbzfV+f6NMSaYgplUpIJpx1xPq6ozVbUXMAZ4CEBEWuAc1aQA7YF4EZlYbtXxHH2Ush3opKonAncAr4hI0wr2N1lV01U1PSkpqebvKgBG9mnLmT2T+NucLHbsz/ckBmOMCYZgJpUcoKPP62TKncLypapfAt1EpBVwDrBBVXNVtQinbnJK2bLuKbGfAK/6rF+gqnvc54uAdUCPwL2dwBER/nBxH4pKlT+9Z10ijTH1RzCTykIgVURSRCQGp9A+y3cBEenu1kYQkYFADLAH57TXUBFp7M4fDqzyWfUcYLWq5vhsK8m9OAAR6QqkAuuD9u6OU+fEeG46szvvLtvOV2tDs5eCMcbUVNCSiqoWAzcDH+IkhBmqmikik0Sk7MqsS4AV7mXBTwOXq2M+8DqwGFjuxjnZZ/PjOLZAfzqwTESWuutOUtWQvsTqhjO60iWxMQ+8nUlBsXWJNMaEP2nIvT7S09M1IyPD0xi+XJPLlVMWcMe5Pbh1eKqnsRhjjD9EZJGqplc0z+6o99jpPZK4oF87nvosm017DnkdjjHGHBdLKiHg/gvSiI4QHpxlXSKNMeHNkkoIaNssjtvP7cFnWbl8mLnT63CMMabWLKmEiJ+f0oVebRP44zuZHCoo9jocY4ypFUsqISIqMoI/jenLtv35/N+n1iXSGBOeLKmEkPQuLbksPZnnv9rAmp15XodjjDE1ZkklxNxzXm+axEXxu7dWWNHeGBN2LKmEmJbxMdwzqhcLNuzlzcVbvQ7HGGNqxJJKCLosvSMndmrOn2evYv/hIq/DMcYYv1lSCUEREcKfxvTl+8OFPDbHukQaY8KHJZUQ1ad9M646pQtT529m6ZZ9XodjjDF+saQSwu44twdJTWL53VsrKCm1or0xJvRZUglhCXHR/O7CNJZv3c/U+dYl0hgT+iyphLiL+rVjWPdWPPZhFrvyGl6XyKKSUi7851c8/Vm216EYY/xgSSXEiQh/HN2HgqJS/jK74RXtX8vIYcXWA3y6epfXoRhj/GBJJQx0TWrCDWd0ZeZ3W/l23R6vw6kz+UUl/N8nzpA1K7cdsLqSMWHAr6QiIsNE5Gr3eZKIpPi53igRyRKRbBG5p4L5o0VkmYgsEZEMERnmM+92EckUkRUiMk1E4tzpD4rIVnedJSJyvs8697r7yhKRkf7EGC5uOqs7HVs24v63V1BYXOp1OHXif/M2seNAPpelJ3OkqIR1uQe9DskYU41qk4qI/B64G7jXnRQN/M+P9SJxWgSfB6QB40UkrdxinwD9VXUAcA3wnLtuB+BWIF1V+wKROC2Ey/xdVQe4j9nuOmnuMn2AUcAzZT3r64O46EgevKgP2bsO8tzc9V6HE3QHC4r51+frOLV7Itef3hWAZTn7PY7KGFMdf45UxgIXA4cAVHUbkODHeoOBbFVdr6qFwHRgtO8CqnpQfxzgKh7wPb8RBTQSkSigMbCtmv2NBqaraoGqbgCy3RjqjeG923BuWhue/jS73hft/zt3A3sOFXLXiJ6ktGpC45hIVmy1pGJMqPMnqRS6v/gVQETi/dx2B2CLz+scd9pRRGSsiKwG3sM5WkFVtwKPA5uB7cB+VZ3js9rN7mmzKSLSoob7u9491ZaRm5vr51sJHb89vzeFJaX8bc4ar0MJmn2HC5n81XrO6d2GEzu1IDJC6NO+KcstqRgT8vxJKjNE5N9AcxH5BfAx8B8/1pMKph1TaVXVmaraCxgDPATgJorRQArQHogXkYnuKv8CugEDcBLOEzXc32RVTVfV9KSkJD/eRmhJaRXPlSd34dWMLazcdsDrcILi31+u52BBMXeO6PHDtL4dmlmx3pgwUGVSEREBXgVeB94AegIPqOo//dh2DtDR53UyVZzCUtUvgW4i0go4B9igqrmqWgS8CZziLrdTVUtUtRQnuZWd4qrR/sLZrWen0qxRNA/PXlnvhsfflZfPC19v5KJ+7endrukP0/slN7NivTFhoMqk4p72ektVP1LVX6vqXar6kZ/bXgikikiKiMTgFNFn+S4gIt3dxIWIDARigD04p72Gikhjd/5wYJW7XDufTYwFVrjPZwHjRCTWvTotFVjgZ6xhpVnjaH41PJWvs/fUu/s3nvlsHYUlpdx+bo+jpp/QoRlgxXpjQp0/p7/michJNd2wqhYDNwMf4iSEGaqaKSKTRGSSu9glwAoRWYJzpdjl6piPc3S0GFjuxjnZXedREVkuIsuAs4Db3f1lAjOAlcAHwE2qWlLTuMPFhKGd6doqnodnr6KopH5cYrx13xFemb+ZSwclk9Lq6NKdFeuNCQ9S3ekTEVmJc9prI84VYIJzENMv6NEFWXp6umZkZHgdRq19vHIn172UwR8u7sNVp3TxOpzjdvfry5j53VY++/WZdGje6Jj5lz77DaUKb9x4igfRGWPKiMgiVU2vaF6UH+ufF+B4TIAM792aU7sn8veP1zBmQAeaNY72OqRaW597kNcX53DlyZ0rTCjgFOunL9hCSakSGVHRdRnGGK9Ve/pLVTcBzYGL3Edzd5rxmIhw3/lp7D9SxD8/Xet1OMfl7x+vJSYygl+e2b3SZaxYb0zo8+eO+tuAqUBr9/E/Ebkl2IEZ/6S1b8plgzry4rcb2bj7kNfh1MrKbQd4Z+k2rj61C0kJsZUuZ8V6Y0KfP4X6a4EhqvqAqj4ADAV+EdywTE3cOaIH0ZER/OX9VV6HUit/+yiLhLgobji9W5XLWbHemNDnT1IRwPcqqhIqvtHQeKR10zh+eWY3Pszcybz14TWK8eLN3/Pxql3ccHrXamtCdme9MaHPn6TyX2C+Ozrwg8A84PmgRmVq7LrTutK+WRx/em8lpWF01/kTc7JIjI/h6lP9Gvja7qw3JsT5U6j/G3A1sBf4HrhaVZ8MclymhuKiI/nNqF6s2HqAmd9t9Tocv3yTvZuvs/fwy7O6Ex/rz4WIVqw3JtT5U6gfCqxV1f9T1X8A2SIyJPihmZq6uH97+ic349EPV3O4sNjrcKqkqjw2J4t2zeKYMKST3+tZsd6Y0ObP6a9/Ab5/Fh5yp5kQExEh3H9hGjsPFDD5y9DuufLp6l18t3kftw5PJS7a/7Y3Vqw3JrT5Vaj36XmCO5Cjf+cqTJ1L79KSC05ox7+/WM+O/aHZc6W0VHnswyw6Jzbmp4OSa7SuFeuNCW3+JJX1InKriES7j9uA0P4zuIG7e1QvStxf3KHoveXbWb0jj9vPcS6Frikr1hsTuvz5Hz0JZ9j5rTjDyw8Brg9mUOb4dEpszNXDuvDG4hyWh1jtobiklL9/tIaebRK4qH/7Wm3DivXGhC5/rv7aparjVLW1qrZR1Z+pav0ab70euums7rSMj+FP74VWz5U3F29l/e5D3DGiR63H77JivTGhy5+rvx4Vkabuqa9PRGS3TxdGE6KaxkVz+7k9mL9hL3NW7vQ6HAAKikv4xydr6Z/cjBFpbWq9HSvWGxO6/Dn9NUJVDwAX4pz+6gH8OqhRmYAYf1JHUls34S+zV1FY7H3PlWnzN7N13xHuGtkTtzdbrVix3pjQ5U9SKRs743xgmqruDWI8JoCiIiO474LebNxzmJe+3ehpLIcLi3nqs3UMSWnJsO6tjnt7Vqw3JjT5k1TeEZHVQDrwiYgkAX5dqyoio0QkS0SyReSeCuaPFpFlIrJERDJEZJjPvNtFJFNEVojINBGJc6c/JiKr3fVmikhzd3oXETnibmuJiDzrT4z13Zk9W3N6jyT+75O1fH+o0LM4XvhmI7sPFvDr4zxKKWPFemNCkz+F+nuAk4F0VS0CDgOjq1tPRCJxWgSfB6QB40UkrdxinwD9VXUAcA3wnLtuB+BWd599gUicHvcAHwF93c6Ta4B7fba3TlUHuI9JGADuO783BwuK+ccn3vRc2X+kiH9/sZ6zeiaR3qVlQLZpxXpjQpNfNwmo6vdl/d5V9ZCq7vBjtcFAtqquV9VCYDrlkpGqHvS5sTIe8D2XEQU0EpEooDGwzV1njqqWjUEyD6jZ3XMNUM+2CYwf3ImX520ie1fd/2X//Ffr2X+kiDtH9AzYNq1Yb0xoqvmdZ/7rAGzxeZ3jTjuKiIx1T6+9h3O0gqpuBR4HNgPbgf2qOqeCfVwDvO/zOkVEvhORL0TktIqCEpHr3VNtGbm5ubV5X2Hp9nN70Cg6kkfquOfKnoMFPD93Axec0I6+7tFFIFix3pjQFMykUtGJ82Oqqqo6U1V7AWOAhwBEpAXOUU0K0B6IL38Zs4jcBxTjdKUEJ/l0UtUTgTuAV0SkaQX7m6yq6aqanpSUVNv3FnZaNYnlprO68/GqXXydvbvO9vuvz9dxpKiE28/tEfBtW7HemNDjz30qIiITReQB93UnERnsx7ZzgI4+r5NxT2FVRFW/BLqJSCvgHGCDqua6dZw3ce7qL4vpKpxLnCeUnT5T1QJV3eM+XwSsw7n82biuPrULyS0a8dC7K+vkF/H2/Ud4ad4mfjIwme6tmwR8+1asNyb0+HOk8gxOoX68+zoPpwBfnYVAqoikiEgMTqF9lu8CItJd3EuBRGQgEAPswTntNVREGrvzhwOr3OVGAXcDF6vqYZ9tJbkXByAiXYFUbIyyo8RFR3LPeb1YvSOP1xdtqX6F4/TPT7NRVW4bnhqU7Vux3pjQ409SGaKqN+FeRqyq3+P88q+SW0y/GfgQJyHMUNVMEZkkImVXZl0CrBCRJTiJ6nJ1zAdeBxYDy904J7vrPAUkAB+Vu3T4dGCZiCx1151k99Qc64IT2jGwU3Men7OGgwXB67myac8hZizcwriTOtGxZeOg7MOK9caEHn+GsC9yjwAUnCMCwK/bs1V1NjC73LRnfZ7/FfhrJev+Hvh9BdO7V7L8G8Ab/sTVkIk4PVfGPvMNz36+jrtGBu6KLF9PfryWqEjhlrMr/OcKCCvWGxN6/DlS+T9gJtBaRB4G5gJ/DmpUJqhO7NSC0QPa85+v1rN135GAb3/NzjzeWrKVq07uQuumcQHfvi8r1hsTWvy5+XEq8BvgLzhXWI1R1deCHZgJrt+M6gXAYx+sDvi2/zZnDfExUUw6o1vAt12eFeuNCS3+9qjfqqpPq+pTQI71qA9/HZo34rrTUnhryTaWbNkXsO0uy9nHB5k7uO60FFrEV1t6O25WrDcmtFiP+gbsxjO706pJLH96N3A9Vx6fs4YWjaO5dlhKQLZXHSvWGxNarEd9A9YkNoq7RvQgY9P3zF7uz8g7VZu/fg9frsnlxjO7kRAXXf0KAWDFemNCi/Wob+AuTe9Ir7YJPPLBKvKLSmq9HVXl8TlZtE6I5cqTuwQuQD9Ysd6Y0GE96hu4yAjhdxeksWXvEV74ZmOtt/PFmlwWbvyeW4anEhcdGbgA/WDFemNCh/WoNwxLbcXZvVrz9KfZ7D5YUOP1y45Skls04vL0jtWvEGBWrDcmdPhz9VeSiPxWRCaLyJSyR10EZ+rOb8/vzeGiEp78eE2N1/1gxQ5WbD3Ar87pQUxUMMcorZgV640JHf78BngbaAZ8jDM8fdnD1CPdWzdh4pBOvDJ/M2t25vm9Xkmp8sRHa+jeugljTzyms0GdsGK9MaHDn6TSWFXvVtUZqvpG2SPokZk6d9s5PYiPjeLh9/zvufLWd1vJ3nWQO87tQWTE8bcJri0r1hsTGvxJKu+KyPlBj8R4rmV8DLcNT+WLNbl8nlV92aywuJQnP1lD3w5NGdWnbR1EWDkr1hsTGvxJKrfhJJZ8ETkgInkiciDYgRlvXHFyZzonNubPs1dRXFL1uKEzMrawZe8R7hzRkwgPj1LAivXGhAp/rv5KUNUIVY1T1abu62M6Kpr6ITYqknvP68WanQeZvrDyniv5RSX889O1pHduwZk9vO+gacV6Y0JDTTo/3u++7uhn50cTpkb2acvglJb8/aM1HMgvqnCZl7/dxM4DBfx6ZE/cPmuesmK9MaGhJp0ff+a+Poh/nR9NmBIR7r8gjT2HCnnms3XHzM/LL+KZz7M5LbUVQ7omehBhxaxYb4z3gtb5EZzWvyKSJSLZInJPBfNHi8gyt4NjhogM85l3u4hkisgKEZkmInHu9JYi8pGIrHV/tvBZ5153X1kiMtKfGE3FTkhuxk8GdmDK3A1s2Xv4qHlT5m7k+8NF3DUiOA2+asuK9cZ4z5+kUqvOj+46TwPnAWnAeBFJK7fYJ0B/VR0AXAM8567bAbgVSFfVvkAkTo97gHuAT1Q11V3/HnedNHeZPsAo4JmynvWmdn49sicREfCIT8+V7w8V8txX6xnZpw39Ozb3LrgKWLHeGO8Fs/PjYCBbVderaiEwHRjtu4CqHvQZATkeN3G5ooBGIhIFNAa2udNHAy+6z18ExvhMn66qBaq6Ach2YzC11K5ZI244vRvvLdvOok17AXj2y3UcLCzmzhA7SgEr1hsTCqpMKiISAWygdp0fOwC+lw/luNPK72OsiKzGuUv/GgBV3Qo8Dmx297lfVee4q7RR1e3uctuB1jXc3/XuqbaM3NxcP95Gw3bDGV1pnRDLH99dxc4D+bz4zUbGDOhAjzYJXod2DCvWG+O9KpOK2zvlCVVdXdb5UVX9vd26okuCjqmgqupMVe2Fc8TxEIBbJxkNpADtgXgRmRig/U1W1XRVTU9K8v5S2FDXOCaKX4/sydIt+7jy+QUUlyi/OifV67AqZcV6Y7zlz+mvOSJyidT8utEcwHfI2mR+PIV1DFX9EugmIq2Ac4ANqpqrqkXAmzjD7wPsFJF2AO7Pslu/a7Q/479LBibTp31TsnbmcWl6RzonxnsdUqWsWG+Mt/xJKncArwGFNbyjfiGQKiIpIhKDU0Sf5buAiHQvS1YiMhDnqrI9OKe9hopIY3f+cKDsCGkWcJX7/CqcAS/Lpo8TkVgRSQFSgQV+xGmqEREh/GlMX07umshtw0P3KAWsWG+M16ptC6yqtTp5rqrFInIz8CHO1VtTVDVTRCa5858FLgGuFJEi4AhwuVu4ny8irwOLgWLgO2Cyu+lHgBkici1O8rnU3V6miMwAVrrr3KSqtW9laI5yYqcWTLt+qNdhVMu3WP/TQcleh2NMgyM+7ecrXsA5UpgApKjqQyLSEWinqmF/FJCenq4ZGRleh2EC7NJnv6FU4Y0bT6l+YWNMjYnIIlVNr2ie3VFv6h0r1hvjnaDeUW+MF6xYb4x3gnZHvTFesWK9Md4J5h31xnjC7qw3xjv+XP01VUQW4VzWKzh31Pvfb9aYOmZ31hvjnWqTimstcKBseRHppKqbgxaVMcepb4dmTF+whZJSJdLjrpTGNCT+NOm6BdgJfAS8izNG17tBjsuY42LFemO84c+Rym1AT1XdE+xgjAkU32J9KA5+aUx95U+hfgtgJ6dNWLFivTHeqPRIRUTucJ+uBz4XkfeAgrL5qvq3IMdmTK1Zsd4Yb1R1pJLgPjbj1FNifKbZ+QQT8uzO+vBQUqps2H2Ir9bmUlxit8CFu0qPVFT1D76vRSTBmaxW+TRhoV9yM/779UbW5R60ukoIUFVyDxaQtSOPrB15rHZ/rt2VR36Rk0weuDCNa4aleBypOR7VFupFpC/wMtDSfb0buFJVM4McmzHHxYr13jlUUEzWzrwfEkjWjjyyduax91DhD8u0ahJLr7YJTBjSmZ5tE3j52038b/4mrj61CzVv32RChT9Xf00G7lDVzwBE5EzgP/zYNMuYkGTD4AdfUUkpG3YfOvroY+cBtuw98sMyjWMi6dEmgRFpbejRJoFebRPo2TaBxCaxR20rUoQ7X1vKt+v2cEr3VnX9VkyA+JNU4ssSCoCqfi4iodv6zxiXFesDR1XZvj/f57TVAVbvyGN97iEK3TpIZISQ0iqefsnNuWxQR3q2TaBX26Ykt2hEhB83oF7Qrx0PvbeSqfM3W1IJY/4klfUicj/OKTCAicCG4IVkTODYnfU1t/9IkXvkceCHukfWzjzy8ot/WKZdszh6tk3gjJ5J9GqbQI82CXRv3YTYqMha7zcuOpKfDkzmhW82sutAPq2bxgXi7Zg65k9SuQb4A06feIAvgav92biIjAL+gdP58TlVfaTc/NHAQzijHhcDv1LVuSLSE3jVZ9GuwAOq+qSIvAr0dKc3B/ap6gAR6YLTcjjLnTdPVSf5E6epv6xY779DBcXc8+Zy3lm67YdpCXFR9GyTwMX927unrZrSs00CzRpHByWGnw3pxHNzNzAjYws3nx3aratNxfwZUPJ74NaabtgdLv9p4FwgB1goIrNUdaXPYp8As1RVRaQfMAPopapZwACf7WzFGSkZVb3cZx9PcPSNmetUdUBNYzX1V1mxfrkV66u0Ze9hfvFSBmt25nH96V05uWsiPdsm0K5ZXJ0WzbsmNeHU7olMW7CFG8/sbkeXYcifsb8+EpHmPq9biMiHfmx7MJCtqutVtRCYDoz2XUBVD+qP/YzjcXu2lDMcJ1lsKheXAJcB0/yIxTRQZcV6q6tU7pvs3Vz81Fy27TvCf68ezG/P781ZvVrTvnkjT67CmjikM1v3HeGz1bvqfN/m+PkzTEsrVd1X9sI9cmntx3odcIZ4KZPjTjuKiIwVkdU4A1VeU8F2xlFx4jgN2Kmqa32mpYjIdyLyhYicVlFQInK9iGSISEZubq4fb8OEMyvWV05VeeHrDVwxZQGJTWJ5++ZhnNEjyeuwOCetDa0TYpk6f1P1C5uQ409SKRWRTmUvRKQzFR9RlFfRnzjHrKeqM1W1FzAGp77y4wZEYoCLgdcq2NZ4jk4224FOqnoicAfwiog0rWB/k1U1XVXTk5K8/w9kgs/urD9WQXEJd7+xjAffWclZPZOY+ctTSGkVGhd1RkdGMO6kjny+Jpctew97HY6pIX+Syn3AXBF5WURexinU3+vHejlAR5/XycC2SpZFVb8EuomI77WE5wGLVXWn77IiEgX8BJ9ivqoWlI2krKqLgHVADz/iNPWcDYN/tF0H8hk3eR4zMnK49ezuTL4inYS44BTea2vc4E4IMG2BtW0KN9UmFVX9ABiI8wt8BjBIVf2pqSwEUkUkxT3iGAfM8l1ARLq7tRFEZCDO+GK+Q+yXPxopcw6wWlVzfLaV5Bb1EZGuQCrOYJimgfMt1jd0S7bs46Kn5rJ6ex7PTBjIHSN6+nUPSV1r37wRZ/dqw4yMLRQW23hg4cSfIxVUdbeqvquq76jqbj/XKQZuBj7EudR3hqpmisgkESm71PcSYIWILMG5UuzyssK9iDTGuXLszWM2XnGd5XRgmYgsBV4HJqnqXn9iNfWbFesdbyzK4bJ/f0t0ZARv3HgK55/QzuuQqjRxaCd2Hyzkg8wdXodiakB+vPiq4UlPT9eMjAyvwzB14NJnv6FU4Y0bG97oQsUlpfzl/dU8P3cDJ3dN5OkJA2kZH+N1WNUqLVXOePwz2jdrxKs3nOx1OMaHiCxS1fSK5vl1pGJMuGuoxfp9hwv5+X8X8vzcDfz8lC68dO3gsEgoABERws8Gd2b+hr2s3ZnndTjGTzVKKiISLyIT3YZdxoSNhlisz9qRx8VPfc2CDXt59JJ+PHhxH6Ijw+vvyMvSk4mOFKbOt4J9uPDn5scYERkjIjNwLtsdDjwb9MiMCaCGVqz/YMUOxj7zNUeKSph2/VAuO6lj9SuFoMQmsZzXtx1vLM7hcGFx9SsYz1WaVETkXBGZgjN45E9xBpTcq6pXq+o7dRWgMYHQUIr1paXKkx+vYdL/FpHaJoF3bh7GoM4tvA7ruEwc2pm8/GLeXbrd61CMH6o6UvkQ6AYMU9WJbiKxa/tMWGoId9YfLCjmxqmLePLjtVwyMJlXrx9K22bhP9LvSV1a0KNNE/5XD++wP5Bf5HUIAVdVUhkEzAM+dsf/uhZntGFjwlJ9LtZv2nOInzzzNR+t3Mn9F6bx+KX9iIuuH/9dRYQJQzqzLGc/y3L2eR1OwMxevp3+f5jDlLn1q5NIpUlFVb9T1btVtRvwIHAiECMi74vI9XUVoDGBUl+L9XPX7ubip75m54ECXrpmCNcOS6l37XjHDuxAo+hIps6rHwX7guIS/jx7FREi/PHdlUyvRyMH+Hvz49eqejPOgJBPAnbRuAk79a1Yr6o8P3cDV06ZT5umscy6+VSGpdbPjolN46IZPaA9by/dyv4j4X/K6OVvN5Hz/REmXzGIM3smce/M5bz13VavwwqIKpOKiCSKyC0i8rSIPA38EshQVb+adBkTSupTsT6/qIS7XlvGQ++u5Ny0Nrz5y1PpnBgaA0IGy4QhnckvKmXm4pzqFw5h+w8X8c9PszkttRXDe7fh2YmDGJLSkjtfW8oHK8J/9ICqrv7qDazAqa2sAdYCJwHL3c6MxoSV+lKs37E/n8snz+ONxTncfk4P/jVhEE1i/WniGt5OSG5G/+Rm/G/+ZsJ5JJCnPlvLgfwifnt+b8Bpo/zcVSfRL7kZt0xbzOdZ4d1HpqojlYeA21T156r6D1V9UlWvAm4B/lw34RkTWOFerF+06Xsuemou2Tvz+PcVg7jtnNSQHBAyWCYM7Uz2roPM3xCew/pt2XuYF7/ZxCUDk+nd7sfOHE1io3jh6sH0aJPADS8v4tt1e6rYSmirKqmcoKozyk9U1TeAvsELyZjgCedi/YyMLYyfPI9G0ZG8+ctTGdmnrdch1bmL+rWnaVxU2N5h//icLETgzhHHduVo1iial68dQqeWjbn2xYUs3vy9BxEev6qSyqFazjMmZIVjsb6opJQHZ2Xym9eXMaRrS2bdfCo92yZ4HZYnGsVEcsmgZD5YsZ3cvAKvw6mRZTn7eHvJNq4dlkK7Zo0qXKZlfAxTrxtC64RYrpqygBVheKq2qqTSWkTuqOBxJ2AtE01YCrdi/d5DhVz5/AJe+GYj1w1L4b8/P4nmjcNjQMhgmTCkM0UlymuLtlS/cIhQVf48exUt42OYdGa3Kpdt3TSOqb8YStO4aK6csiDsBtOsKqn8B0io4NEEeC74oRkTeOFUrF+1/QAXPzWXRZu/54lL+/O7C9OICrMBIYOhe+smDO3aklfmbw6b2tinq3cxb/1ebhueSlM/umx2aN6IqdcNITJCmPDcfDbuDp+TQ1Xd/PiHyh5A6P+PNKYS4VCsf3/5dn7yzDcUlZTy2g0nc8mgZK9DCikTh3Ym5/sjfLkm1+tQqlXWzyalVTw/G9LJ7/W6tIpn6nVDKCopZcJz88n5/nAQowyc2v7Zc4c/C4nIKBHJEpFsEbmngvmjRWSZiCwRkQwRGeZO7+lOK3scEJFfufMeFJGtPvPO99neve6+skRkZC3fm6nnQr1Yv2Lrfm56ZTG92zkDQvbv2NzrkELOiLS2tGoSy9QwGA/stUU5ZO86yG9G9qxx64EebRJ4+dohHMgvYuJz89l1ID9IUQZObZNKtdcwuv3inwbOA9KA8SKSVm6xT4D+qjoAuAb3tJqqZqnqAHf6IOAwMNNnvb+XzVfV2e7+0nDaDPcBRgHPlPWsN8ZXKBfrS0qV+2Yup2V8LP+9ejCtm4b/gJDBEBMVweUnJfPp6l1s3XfE63AqdaigmL99tIZBnVswqm/trtbr26EZL1w9mF15BUx4bj57DxUGOMrAqm1S8ee8wWAgW1XXq2ohMB0YfdRGVA/qj3cxxVey3eHAOlWt7k+S0cB0VS1Q1Q1AthuDMUcJ5WL9K/M3sTRnP/df2Jtmjao/996QjR/cCYWQHjfrP1+tJzevgN+e3+u4xmMb1LkFz191Epv3HuaK5+eH9FA1Vd1Rn+eedir/yAPa+7HtDoDv5Rk57rTy+xkrIquB93COVsobB0wrN+1m97TZFBEpaxbh7/6ud0+1ZeTmhv75WBN4oVqs35WXz6MfZnFq90Qu7u/Pf7GGLblFY87q2ZrpC7dQVBJ6XTl25eUz+cv1nNe3LYM6tzzu7Z3cLZFnrxjEmp15XP3fBRwqCM2mZVUV6hNUtWkFjwRV9WdMiIrS8jFHIqo6U1V7AWNw7uL/cQMiMcDFwGs+k/+F0+dlAE4nyidquL/JqpququlJSXZldEMVisX6h99bRUFRKQ+N7lvvRhkOlolDO5GbV8CczJ1eh3KMv3+0lsLiUn4zqlfAtnlWz9b8c/yJLM3Zz3UvZpBfVBKwbQdKMK9PzAF8e5gmA9sqW1hVvwS6iYjvMKvnAYtVdafPcjtVtURVS3Euey47xVWj/ZmGLdSK9V9n7+btJduYdGY3uiY18TqcsHFGj9bO5bchVrBfuzOPVxduZuLQzqS0CuxAn6P6tuOJS/szb8MeJv1vEQXFoZVYgplUFgKpIpLiHnGMA2b5LiAi3cX9k0xEBgIxgO+gN+Mpd+pLRNr5vByLM+gl7rbHiUisiKQAqcCCAL4fU4+EUrG+oLiE+99aQefExvyymhvjzNEiI4SfDenEN+v2hMwfCAB//WA18TFR3HJ296Bsf8yJHfjz2BP4PCuX26YtoTiETv8FLamoajFwM05b4lXADFXNFJFJIjLJXewSYIWILMG5UuzyssK9iDQGzgXeLLfpR0VkuYgsA84Cbnf3lwnMAFYCHwA3qWpopXATMkKpWP/vL9azfvch/ji6b73p1liXLkvvSFSE8EqIjAc2b/0ePl61i0lndiOxSWzQ9jN+cCfuvzCNDzJ38OvXl1EaIqdygzpetnu57+xy0571ef5X4K+VrHsYSKxg+hVV7O9h4OHaxmsajlAp1m/cfYinPsvmwn7tOKOH1fhqIykhlpF92/L6ohx+PbKnp4m5tNQZjqVdsziuHZYS9P1dOyyFI4XFPD5nDXHRkfx5rPf1OBvzwTRYXhfrVZX7315BTGQE919Y/hYuUxMTh3Rm/5Ei3lnqbRn1nWXbWJaznztH1F1yu/nsVH55ZjemLdjMQ++u8rzXjCUV02B5Xax/b/l2vlq7m7tG9KCN3eR4XIZ2bUm3pHhPh8QvKC7hsQ+z6N2uKWNPPOZuhqD69cie/PyULkz5egNPzFlTp/suz5KKabC8LNbn5Rfxx3dW0rdDU644uUud77++EREmDOnMki37PBsuvqzv/L3n9SKyjhuniQi/vyiNcSd15KnPsnn6s+w63b8vSyqmwfKyWP/EnDXkHizg4TEn1PkvoPrqkoHJxEVHeHK04tt3/nSPamMiwsNjT2D0gPY89mEWU+Zu8CQOSyqmwfKqWL9i635e+nYjE4d0tsEiA6hZ42gu6teet5dsJS+/bocxKd933iuREcLjl/ZnRFob/vjuSk+GsLGkYhq0ui7W+w4YedfInnWyz4Zk4tDOHC4s4a3vttbZPivrO++V6MgI/vmzEzmjRxL3zlzO20vq7rMASyqmgavrYr0NGBlc/Ts254QOzfjfvM11dhXUYx9mERFRcd95r8RGRfLsxEEM7tKSO2Ys5YMVO+ps35ZUTINWl8V6GzCybkwY0omsnXlkbPo+6PtalrOPWUur7jvvlUYxkTz/85Pol9yMW6Yt5vOsXXWyX0sqpkGry2K9DRhZNy4e0J6E2CimzgvueGCqysPvOX3nbzgjNIfXaRIbxQtXDya1dQI3vLyIb9ftqX6l42RJxTRodVWsn7vWBoysK41jovjJwA7MXr6DPQcLgrafT1fvYv4G//vOe6VZo2hevnYwHVs25toXF7J4c3CP4CypmAYv2MX6/KIS7n/bBoysSxOGdqawpJTXF+UEZfu17TvvlcQmsUy9bghJCbFcNWVBUO/lsaRiGrxgF+v//cV6Nuw+xEM2YGSd6dEmgcEpLXllweagDLQ4I8PpO3/3qJr3nfdKm6ZxTL1uCAmxUVw5ZQFrd+YFZT/h8WkYE0TBLNZv3H2Ipz93Boz06qa4hmrCkE5s2nOYr7J3B3S7ZX3n0zu3YGSf2vWd90pyi8ZM/cVQIiOEh2evCso+LKmYBi9YxfqyASNjbcBIT4zq25bE+JiAF+z/89V6dh8s4N7ze4flBRcpreKZ9ouh/OPyE4OyfUsqpsELVrG+bMDIO23ASE/ERkVyaXpHPl61k+37jwRkm0f3nW8RkG16oXvrJjRrHJyLCyypGEPgi/UH3AEjT+jQzAaM9NCEIZ1QYPqCLQHZXjD6ztc3QU0qIjJKRLJEJFtE7qlg/mgRWSYiS0QkQ0SGudN7utPKHgdE5FfuvMdEZLW73kwRae5O7yIiR3zWebb8/oypTKCL9X8rGzBybF8bMNJDHVs25oweSUxfuJmi42y5G8y+8/VJ0JKKiETitAg+D0gDxotI+RPLnwD9VXUAcA3wHICqZqnqAHf6IOAwMNNd5yOgr6r2A9YA9/psb13Zeqo6CWP8FMhi/fIcZ8DIK4Z2pl9y8+Penjk+E4Z0ZueBAj5ZtfO4tvPI+07f+VuHpwYosvopmEcqg4FsVV2vqoXAdGC07wKqelB/HKAnHqjo3MNwnGSxyV1njqoWu/PmAclBid40KIEq1peUKve95QwYeecIGzAyFJzdqzXtm8Ud15D4367bwyerd3HjWd1oGR8TwOjqn2AmlQ6A74nMHHfaUURkrIisBt7DOVopbxwwrZJ9XAO87/M6RUS+E5EvROS0ilYQkevdU20Zubm5/rwP0wAEqlj/yvxNLLMBI0NKZIQwbnAnvlq7mw27D9V4/dJS5S/vO33nrzk1+H3nw10wk0pFJ5KPORJR1Zmq2gsYAzx01AZEYoCLgdeO2bjIfUAxMNWdtB3opKonAncAr4jIMeNQq+pkVU1X1fSkJLtvwPzoeIv1u/LyefSDLIZ1b2UDRoaYcSd1JCpCmFaL/iJe9J0PZ8FMKjlAR5/XycC2yhZW1S+BbiLSymfyecBiVT3qZKiIXAVcCEwoO32mqgWqusd9vghYB4TOWNQm5B1vsf7h91ZRUFzKH0f3Ccv7F+qz1k3jGNGnDa9lbCG/qMTv9bzsOx+ugplUFgKpIpLiHnGMA2b5LiAi3cX93yciA4EYwHcYzfGUO/UlIqOAu4GLVfWwz/Qk9+IARKQrkAqsD/i7MvXW8RTrywaMvNEGjAxZE4Z05vvDRcxevt3vdV76xuk7/9vz677vfLgKWlJxi+k3Ax8Cq4AZqpopIpNEpOzKrEuAFSKyBOdKscvLjjxEpDFwLvBmuU0/BSQAH5W7dPh0YJmILAVeByap6t5gvT9T/9S2WF82YGSXxMbcaANGhqxTuiXStVW83wX7fYcL+eenazm9RxKnpdqpcn9FBXPjqjobmF1u2rM+z/8K/LWSdQ8DiRVM717J8m8AbxxPvKZhq22xvmzAyJeuGWzn3EOYiPCzIZ3403urWLX9QLWtf5/+LJu8gmLuPc9udKwJu6PeGB81LdbbgJHh5aeDkomNimDq/KrHAwu1vvPhxJKKMT5qUqy3ASPDT/PGMVzYrz0zF2/lYEFxpcuFYt/5cGFJxRgfNSnWv7vMBowMRxOGduJQYQlvfbe1wvmh3Hc+HFhSMcaHv8X6A/lFPPSuDRgZjk7s2Jy0dk2ZOn8zPw7o4SjrO58YH8OkEO07H+osqRjjw99ivQ0YGb5EhAlDO7Fq+wEWb9531Lwf+s6fk0pCCPedD2WWVIwpp7pivQ0YGf7GDOhAk9ioowr2vn3nxw8O/b7zocqSijHlVFWsLxswMrFJLHeNtAEjw1V8bBRjT+zAu8u28/2hQiA8+86HIvvkjCmnqmL9VHfAyN9d0JumdnokrE0Y2onC4lJeX5QT1n3nQ01Qb340Jhz5FusvGfRjZ4Vdefk8ZgNG1hu92jYlvXMLXlmwmbyCYnYfLODfVwyycduOkx2pGFNOZcX6P71rA0bWNxOGdmLD7kM89elazj8hvPvOhwpLKsZUoHyxfu7a3cxaagNG1jfn9W1Hi8bRRIjwm5E2HEsg2OkvYyrQL7kZ//16I+tyD9KpZWMbMLKeiouO5OGxJ3Awv5gu1nc+ICypGFMB32L9+8t3sGH3IV6+1gaMrI/OP6Gd1yHUK5ZUjKlAWbH+3WXb+HrdHi7q396GPzfGD1ZTMaYCZcX6z7JynQEjL+jtdUjGhAVLKsZUoq97CuyukT1pbQNGGuOXoCYVERklIlkiki0i91Qwf7SILHM7OGaIyDB3ek93WtnjgIj8yp3XUkQ+EpG17s8WPtu7191XloiMDOZ7M/Xf+MGd+OWZ3Zg4tLPXoRgTNqT8KJ0B27DTL34NTkvgHJye9eNVdaXPMk2AQ6qqItIPp+Vwrwq2sxUYoqqbRORRYK+qPuImqhaqereIpOH0sx8MtAc+BnqoakllMaanp2tGRkYg37YxxtR7IrJIVdMrmhfMI5XBQLaqrlfVQmA6MNp3AVU9qD9mtXigogw3HFinqmUjv40GXnSfvwiM8Zk+XVULVHUDkO3GYIwxpo4EM6l0ALb4vM5xpx1FRMaKyGrgPeCaCrYzDucIpEwbVd0O4P5sXZP9GWOMCZ5gJpWKxrE45khEVWe6p7zGAA8dtQGRGOBi4LVA7U9ErnfrNxm5ubl+bNYYY4y/gplUcoCOPq+TgW2VLayqXwLdRKSVz+TzgMWqutNn2k4RaQfg/txVk/2p6mRVTVfV9KQku+/AGGMCKZhJZSGQKiIp7hHHOGCW7wIi0l3ckflEZCAQA+zxWWQ8R5/6wt3GVe7zq4C3faaPE5FYEUkBUoEFAXw/xhhjqhG0O+pVtVhEbgY+BCKBKaqaKSKT3PnPApcAV4pIEXAEuLyscC8ijXGuHLuh3KYfAWaIyLXAZuBSd3uZIjIDWAkUAzdVdeWXMcaYwAvaJcXhwC4pNsaYmvPqkmJjjDENTIM+UhGRXGBTFYu0AnbXUTg1YXHVjMVVMxZXzTTEuDqraoVXOjXopFIdEcmo7BDPSxZXzVhcNWNx1YzFdTQ7/WWMMSZgLKkYY4wJGEsqVZvsdQCVsLhqxuKqGYurZiwuH1ZTMcYYEzB2pGKMMSZgLKkYY4wJmAafVKrqMumzzJkist9nmQeCFMsUEdklIit8plXa6bLculV22QxCXI+JyGq3c+dMEWleybobRWR5WXfPOojrQRHZ6vNvdX4l69b15/WqT0wbRWRJJesG8/PqKCKficgqEckUkdvc6Z5+x6qIy9PvWBVxefodqyIuz79jAKiqPdwHzhhlO3Bu7PGdfibwbh3s/3RgILDCZ9qjwD3u83uAv1YS9zqgK86gnEuBtCDHNQKIcp//taK43HkbgVZ1+Hk9CNzlx79znX5e5eY/ATzgwefVDhjoPk/A6cya5vV3rIq4PP2OVRGXp9+xyuIKhe+YqtqRSjnlu0zWKXWG/99bbnJlnS59VdtlM9BxqeocVS12X87DaTVQpyr5vPxR559XGRER4DKOHX076FR1u6oudp/nAatwGtl5+h2rLC6vv2NVfF7+qPPPq2y+l98xsNNf5ZXvMunrZBFZKiLvi0ifOoypsk6XvrzuenkN8H4l8xSYIyKLROT6OornZveUyZRKTuV4+XmdBuxU1bWVzK+Tz0tEugAnAvMJoe9Yubh8efodqyCukPiOVfJ5efods6Tikqq7TC7GOSXWH/gn8FYdhuYPv7peBmXHIvfhtBqYWskip6rqQJyGazeJyOlBDulfQDdgALAd5zRAeZ59XlTcI8hX0D8vEWkCvAH8SlUP+LtaBdMC+plVFpfX37EK4gqJ71gV/46efscsqfyooi6TAKjqAVU96D6fDUTL0R0qg6myTpe+atRlM1BE5CrgQmCCuidry1PVbe7PXcBMnNMCQaOqO1W1RFVLgf9Usj+vPq8o4CfAq5UtE+zPS0SicX4RTVXVN93Jnn/HKonL8+9YRXGFwnesis/L8++YJZUfVZrdRaSte54SERmM87ntqWjZIKis06WvartsBpqIjALuBi5W1cOVLBMvIgllz3EKrysqWjaAcbXzeTm2kv3V+eflOgdYrao5Fc0M9uflfoefB1ap6t98Znn6HassLq+/Y1XE5el3rIp/R/D4OwbY1V/uHz+NcZJEM59pk4BJ7vObgUycKzjmAacEKY5pOIfTRTh/6VwLJAKfAGvdny3dZdsDs33WPR/nKpB1wH11EFc2zjnjJe7j2fJx4Vz5stR9ZNZRXC8Dy4FlOP+J24XC5+VOf6HsO+WzbF1+XsNwTsEs8/l3O9/r71gVcXn6HasiLk+/Y5XFFQrfMVW1YVqMMcYEjp3+MsYYEzCWVIwxxgSMJRVjjDEBY0nFGGNMwFhSMcYYEzCWVIzxk4ioiDzh8/ouEXkwwPu42mek2UKf0WQfqeF2Zkslo/oaE0x2SbExfhKRfJz7T05S1d0ichfQRFUfDNL+NgLpqro7GNs3JhjsSMUY/xXj9P2+vfwMEXlBRH7q8/qg+/NMEflCRGaIyBoReUREJojIAvcopFt1OxXHYyKywl3ncp9tfylOr5GVIvKsiES48zaWDSUkIle6gx8uFZGX3WmXuttbKiJfBuLDMQYgyusAjAkzTwPLROTRGqzTH+iNMxz+euA5VR0sTnOlW4BfVbP+T3AGL+wPtAIW+iSCwTg9PjYBH7jLvl62ojgjat+HM4jgbhFp6c56ABipqlvtNJkJJDtSMaYG1BkN9iXg1hqstlCdHhgFOEN2zHGnLwe6+LH+MGCaOoMY7gS+AE5y5y1Qp2dHCc7wMMPKrXs28HrZKTRVLevz8jXwgoj8AqehlDEBYUnFmJp7EmecsXifacW4/5/cAf9ifOYV+Dwv9Xldin9nCyoaRr1M+aJo+ddSwTRUdRLwO5yRdJeISKIfcRhTLUsqxtSQ+9f+DJzEUmYjMMh9PhqIDuAuvwQuF5FIEUnCaVe8wJ032B0JNwK4HJhbbt1PgMvKkkbZ6S8R6aaq81X1AWA3Rw/TbkytWVIxpnaewKlvlPkPcIaILACGAIcCuK+ZOCPSLgU+BX6jqjvced8Cj+AMX77BXfYHqpoJPAx8ISJLgbKh0h9zi/4rcJLW0gDGaxowu6TYmDAlImcCd6nqhR6HYswP7EjFGGNMwNiRijHGmICxIxVjjDEBY0nFGGNMwFhSMcYYEzCWVIwxxgSMJRVjjDEB8//kXp3iMoy3KQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "topics: 8 coherence: 0.39008303975333114\n", + "topics: 10 coherence: 0.38510483609474594\n", + "topics: 12 coherence: 0.37971670339959324\n", + "topics: 14 coherence: 0.38554514200014817\n", + "topics: 16 coherence: 0.37036066498440806\n", + "topics: 18 coherence: 0.37529464387039135\n", + "topics: 20 coherence: 0.37775907219201404\n", + "topics: 22 coherence: 0.3782917153376321\n", + "topics: 24 coherence: 0.37085971741257806\n", + "topics: 26 coherence: 0.3763805143792078\n", + "topics: 28 coherence: 0.3732050638274837\n", + "=== 8\n", + "=== 10\n", + "=== 12\n", + "=== 14\n", + "=== 16\n", + "=== 18\n", + "=== 20\n", + "=== 22\n", + "=== 24\n", + "=== 26\n", + "=== 28\n", + "CPU times: user 59.4 s, sys: 4.47 s, total: 1min 3s\n", + "Wall time: 27.7 s\n" + ] + } + ], + "source": [ + "%%time\n", + "tm_utils.compute_coherence(dictionary, idword, data_lemmatized, corpusname=corpusname, datadir=DATA,\n", + " stop=30, step=2)\n", + "# takes about 30 secs for 112 documents\n", + "# optimal topic no = 12\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting and visualizing" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "<link rel=\"stylesheet\" type=\"text/css\" href=\"https://cdn.jsdelivr.net/gh/bmabey/pyLDAvis@3.3.1/pyLDAvis/js/ldavis.v1.0.0.css\">\n", + "\n", + "\n", + "<div id=\"ldavis_el296501403318545376729744612273\"></div>\n", + "<script type=\"text/javascript\">\n", + "\n", + "var ldavis_el296501403318545376729744612273_data = {\"mdsDat\": {\"x\": [-0.1470641511743043, -0.13188261220439146, -0.06626284128011055, -0.12260722313250477, 0.06605942509624224, -0.26528665141116614, 0.20943352301858226, 0.10426879509418464, 0.08797196541318256, 0.08992693566320187, 0.08793879119221734, 0.08750404372486628], \"y\": [-0.04807526227907981, 0.08718162337139906, -0.19331084240568047, 0.27373259034688113, 0.30085005914992113, -0.06697700513734624, 0.09778429549543419, -0.09629659528733255, -0.09052726649688458, -0.0892961961487958, -0.08742963856244731, -0.08763576204606863], \"topics\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], \"cluster\": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], \"Freq\": [31.209692099401813, 30.771349174558303, 12.513747842096087, 10.017126532360846, 7.46864363894131, 6.503655600649207, 1.0800763362758308, 0.30349918644606994, 0.06772558455376775, 0.05189772043652145, 0.010469995103149669, 0.0021162891770871743]}, \"tinfo\": {\"Term\": [\"kommission\", \"vereinigung\", \"stellen\", \"zahlen\", \"prasident\", \"sitzung\", \"ausschu\\u00df\", \"kommissionen\", \"osterreichische\", \"folgend\", \"schriftfuhrer\", \"international\", \"berichten\", \"arbeiten\", \"osterr\", \"mayerhofer\", \"bibliothekartag\", \"ausbildung\", \"finden\", \"gattin\", \"leitung\", \"hoheren\", \"teilnehmer\", \"stattfinden\", \"fallen\", \"personen\", \"bericht\", \"dienen\", \"arbeit\", \"tatigkeit\", \"strahlen\", \"vermerk\", \"streichen\", \"sachtitel\", \"zeile\", \"eintragen\", \"library_association\", \"dollar\", \"merlingen\", \"sendungen\", \"baden\", \"ubersetzung\", \"verfassers\", \"zetteldrucke\", \"hauses\", \"papyrussammlung\", \"verfassern\", \"notgemeinschaft\", \"xviii\", \"fahrkarten\", \"anmeldegebuhr\", \"stuck\", \"betrauen\", \"vodrazka\", \"linzer\", \"geb\\u00e4ren\", \"format\", \"klgft\", \"methode\", \"serie\", \"minuten\", \"bezeichnung\", \"angabe\", \"titel\", \"verfasser\", \"fachversammlung\", \"zdarzil\", \"wertvoll\", \"anlage\", \"anmeldung\", \"munchen\", \"zettel\", \"vorschrift\", \"namen\", \"teilen\", \"mitteilungen\", \"deutsch\", \"katalog\", \"osterr\", \"gleich\", \"wichtig\", \"werke\", \"aufnahme\", \"wiener\", \"fachsitzung\", \"stellen\", \"sammlung\", \"bucher\", \"folgen\", \"wahren\", \"vereinigung\", \"konnen\", \"erfolgen\", \"hofrat\", \"finden\", \"mitglieder\", \"erscheinen\", \"schriften\", \"schrift\", \"verschieden\", \"arbeiten\", \"bringen\", \"tagung\", \"bibliographie\", \"fragen\", \"komitees\", \"mannern\", \"sektion\", \"schaffen\", \"beeinflussen\", \"ablegen\", \"kurzer_begru\\u00dfung\", \"zuruckgelegt\", \"erlernen\", \"inner\", \"spanisch\", \"zulassen\", \"renner\", \"verlaufen\", \"antiquare\", \"borsenblatt\", \"adalbert_stifter\", \"fruheren\", \"dienste\", \"kongresses\", \"wichtigkeit\", \"amtszeit\", \"dringend\", \"beisitzer\", \"einrichten\", \"kreise\", \"ehrenprasident\", \"gerne\", \"instruktion\", \"akademisch\", \"hoffen\", \"horsaal\", \"kassenbericht\", \"stimmen\", \"mitringer\", \"osterreichi_schen\", \"beilage\", \"jancik\", \"vollversammlung\", \"wahlgang\", \"lebendig\", \"kommend\", \"vorstandes\", \"stellvertreter\", \"stummvoll\", \"vereines\", \"punkt_tagesordnung\", \"durchgefuhrten\", \"satzungen\", \"schlie\\u00dfen\", \"vorsitzend\", \"worten\", \"ordentliche\", \"jahresbeitrag\", \"mitglieder\", \"osterr\", \"vereinigung\", \"antrag\", \"direktor\", \"schriftfuhrer\", \"konnen\", \"verein\", \"kurz\", \"arbeit\", \"ausschu\\u00df\", \"folgend\", \"einstimmig\", \"bericht\", \"beschlie\\u00dfen\", \"tagung\", \"bringen\", \"arbeiten\", \"besonder\", \"stellen\", \"ausstellung\", \"kollegen\", \"dienen\", \"deutsch\", \"berichten\", \"erscheinen\", \"fragen\", \"hofrat\", \"mitteilungen\", \"erfolgen\", \"einheiten\", \"entlehnungen\", \"pakete\", \"prachtbau\", \"thesen\", \"schallplatten\", \"auswarts\", \"betrage\", \"anzufuhren\", \"anfugen\", \"tonbander\", \"atlanten\", \"umfangma\\u00dfig\", \"statistisch_erfa\\u00dft\", \"vorneherein_begrenzte\", \"hauptkataloge\", \"mappen\", \"zugmappen\", \"sonstigen_objekte\", \"jugend\", \"volkskunde\", \"erlagscheinen\", \"beirates\", \"biographie\", \"tauschzwecke\", \"lohnen\", \"tatsachlichen\", \"tageszeitungen\", \"erworben\", \"ztgen\", \"einzelwerke\", \"zahlen\", \"gegensatz\", \"anhang\", \"statistiken\", \"verluste\", \"statistik\", \"reihen\", \"vermehrung\", \"objekte\", \"summe\", \"ausgaben\", \"schillingen\", \"serien\", \"bande\", \"sonstig\", \"benutzung\", \"schaft\", \"schriften\", \"madden\", \"druckschriften\", \"erbitten\", \"benutzen\", \"ausschu\\u00df\", \"einzeln\", \"dissertationen\", \"mitglieder\", \"siehe\", \"vereinigung\", \"ordentlich\", \"biblos\", \"kommission\", \"entsprechen\", \"osterr\", \"konnen\", \"arbeit\", \"tagung\", \"ausschusses\", \"erscheinen\", \"bibliothekartag\", \"unterricht\", \"vorsitzend\", \"mitteilungen\", \"bitte_vorzumerken\", \"kongre\\u00dfgebuhr\", \"beobachter\", \"autobusse\", \"abonnement\", \"rehberger\", \"umgebung\", \"offen\", \"naheren\", \"abanderung\", \"nehmern\", \"licht_bildern\", \"gastgeber\", \"vorsprache\", \"landesarchiv\", \"firmen\", \"uberwiesen\", \"mitmachen\", \"preisgrenze\", \"lemmerich\", \"dienstkl\", \"gegebenheit\", \"uberweisungen\", \"annemarie\", \"exkursion\", \"zessner\", \"autobusfahrt\", \"spatestens\", \"volume\", \"kategorie\", \"interessenten\", \"kenntnis\", \"delegieren\", \"rennhofer\", \"leoben\", \"prasidium\", \"reise\", \"mitgliederliste\", \"unterbringung\", \"anmelden\", \"bibliothekartag\", \"fahrt\", \"anmeldungen\", \"sitzung\", \"tagesordnung\", \"gebeten\", \"verleger\", \"stehen\", \"vereinigung\", \"konferenz\", \"einzahlen\", \"prasident\", \"teilnehmer\", \"kommissionen\", \"m\\u00fcssen\", \"moglichkeit\", \"personen\", \"josefsplatz\", \"biblos\", \"preis\", \"eigentumer_herausgeber\", \"international\", \"berichten\", \"osterreich\", \"mitgliedern\", \"mitglieder\", \"fragen\", \"tagung\", \"osterr\", \"bericht\", \"finden\", \"kommission\", \"gemeinsam\", \"hauptverbandes\", \"ausstattung\", \"theol\", \"arbeitskreises\", \"landesarchiv_eisenstadt\", \"justiz\", \"hochsch\", \"landesrat\", \"wertgrenze\", \"kulturinstitut\", \"ornig\", \"biologie\", \"symposium\", \"teilnehmerzahl\", \"besuches\", \"razumovsky\", \"swoboda\", \"rentabilitat\", \"amstadter\", \"dienstzweiges\", \"hauptverband\", \"abliefern\", \"demgema\\u00df\", \"untersuchung\", \"hauptreferat\", \"bezugsrecht\", \"soziologie\", \"landwirtschaft\", \"erholsam\", \"dienstprufung\", \"bozen\", \"gattin\", \"hilfsmittel\", \"regierung\", \"dokumentalisten\", \"helene\", \"brief\", \"wissenschaft_forschung\", \"hochschule\", \"librarianship\", \"auszeichnung\", \"gegenstanden\", \"stellungnahme\", \"einbeziehung\", \"innsbruck\", \"antragsliste\", \"personen\", \"person\", \"ausschu\\u00dfsitzung\", \"richten\", \"prasidium_schriftleitung\", \"information\", \"eisenstadt\", \"josefsplatz\", \"sitzung\", \"leitung\", \"landes\", \"interessieren\", \"prasident\", \"teilnehmer\", \"ausbildung\", \"beschlie\\u00dfen\", \"druck_osterreichische\", \"sprechen\", \"vereinigung\", \"folgend\", \"bibliothekartag\", \"kommission\", \"kommissionen\", \"verleger\", \"mayerhofer\", \"fragen\", \"osterr\", \"osterreichische\", \"nachsten\", \"berichten\", \"finden\", \"kassenprufer\", \"veranstaltern\", \"kulturgut\", \"morgens\", \"parteienverkehr\", \"sondermittel\", \"trager\", \"klaren\", \"ausfuhrlicher_bericht\", \"helfern\", \"messe\", \"medaille\", \"sorge\", \"landischen\", \"ansprache\", \"stadtbibl\", \"dankbar\", \"genie\\u00dfen\", \"forstner\", \"interesses\", \"streichquartett\", \"tagungsmappen\", \"osterreichern\", \"mitbringen\", \"einblicke\", \"schiff\", \"ostlichen\", \"zwecklos\", \"rechtliche\", \"kunftiges\", \"schildern\", \"wissenschaftler\", \"vorziehen\", \"feierlich\", \"polnisch\", \"resolution\", \"ernst\", \"dotation\", \"burgermeister\", \"platt\", \"einzig\", \"erfolgreich\", \"verlieren\", \"autographen\", \"beteiligung\", \"wiederaufnahme\", \"schlu\\u00dfsitzung\", \"berufsstand\", \"ungarisch\", \"fuhrung\", \"bereitschaft\", \"forschung\", \"schaffung\", \"prasident\", \"aufgaben\", \"vereinigung\", \"scheidend\", \"teilnehmer\", \"direktor\", \"osterr\", \"tatigkeit\", \"bericht\", \"danken\", \"erscheinen\", \"kollegen\", \"biblos\", \"befinden\", \"sprechen\", \"organisation\", \"gewahlt\", \"halten\", \"neuwahl\", \"stehen\", \"folgend\", \"mitteilungen\", \"anschlie\\u00dfen\", \"bibliothekartag\", \"arbeit\", \"kommission\", \"ausschusses\", \"bedienstete\", \"ausbildungskurs\", \"dienstpflichten\", \"kursbesuch\", \"sechswochigen\", \"sohin\", \"anzugehoren\", \"kursbesuches\", \"bediensteten\", \"zusammentreten\", \"prufungswerber\", \"launig\", \"verbindungsmann\", \"amtieren\", \"dienstrecht\", \"verringern\", \"antwortrede\", \"auflassen\", \"breinlxx\", \"brunner\", \"christine\", \"dogent\", \"gamsjagerx\", \"kolark\", \"konstutierte\", \"kopplx\", \"kurzfilmen\", \"leitfadens\", \"liothekstechnik\", \"magnetband\", \"freistellen\", \"stundenplan\", \"ministerialrat\", \"kommission\", \"gema\\u00df\", \"normung\", \"gehobenen_dienstes\", \"bereich\", \"kommissionen\", \"hoheren\", \"zulassung\", \"rechtsfragen\", \"offentlichen_privaten\", \"kontakt\", \"praktisch\", \"erwahnten\", \"gehort\", \"information\", \"dokumentation\", \"stattfinden\", \"fallen\", \"mayerhofer\", \"ausschu\\u00df\", \"prasident\", \"stellen\", \"osterreichische\", \"tatigkeit\", \"international\", \"ausbildung\", \"finden\", \"schriftfuhrer\", \"berichten\", \"vorbereiten\", \"folgend\", \"osterr\", \"vereinigung\", \"sitzung\", \"tagungsburo\", \"studentenheimen\", \"tagungsmappe\", \"eisenerz\", \"roseggergasse\", \"krypta\", \"entlehnstelle\", \"huttenwerkes\", \"ummeldungen\", \"befahrung\", \"prabichl\", \"mitfahrend\", \"albinger\", \"erzberges\", \"bundesamt\", \"beheben\", \"gutscheine\", \"sitzungszimmer\", \"studentenheim\", \"hauer\", \"margarite\", \"datte\", \"ubernachtungen\", \"gebene\", \"pandesregierung\", \"hinten\", \"ankommend\", \"schmied\", \"parkend\", \"abstellend\", \"wagen\", \"eigen\", \"leoben\", \"ruckkehr\", \"zentralbucherei\", \"oberosterr\", \"entgegennahme\", \"erliegen\", \"vorweis\", \"feierlichen_eroffnung\", \"anmeldegebuhr\", \"devisen\", \"heurigenabend\", \"speisen\", \"auinenngen\", \"wildgrube\", \"mauig\", \"privatgebrauch\", \"renng\", \"mactes\", \"jahresmitte\", \"heuriger\", \"gebaente\", \"oevorsteht\", \"schingsfeier\", \"tarife\", \"dienststandes\", \"umrechnungskurs\", \"\\u043b\\u0430h\\u043e\\u0432\\u043d\\u03bf\\u0430\\u0438ste\", \"beteiligend\", \"fresno\", \"auslage\", \"jahresbudget\", \"uberwindung\", \"l\\u00fcgen\", \"derzufolge\", \"mindestbudget\", \"gesetzen\", \"buchhandlerver\", \"stellagen\", \"nerrn\", \"moglichst\", \"angezeigt\", \"photothek\", \"vereinbarung\", \"asnoe\", \"stimmberechtig\", \"bewilligung\", \"zimmerzahl\", \"theksbenutzer\", \"hochofen\", \"chrift\", \"radio\", \"angeheftet\", \"excursionen\", \"obige\", \"kommiss\", \"aktenzahl\", \"abtrennen\", \"dettelmeier\", \"visuelle\", \"sebratente\", \"diensteinbu\\u00dfe\", \"innenaufnahmen\", \"unterstehend\", \"landeswahrung\", \"fahrpreises\", \"naune\", \"ausfluge\", \"kartag\", \"neugewahlten\", \"zugeordnet\", \"ortsublichen\", \"ubersendenden_vollmachten\", \"freier\", \"einreichen\", \"wahlgangen\", \"erwartend\", \"abgefuhrt\", \"bemangelt\", \"zuvor\", \"streng\", \"rechnungslegung\", \"grundlichen\", \"insbruck\", \"lokumentation\", \"statistische\", \"kammel_druck\", \"omuomesiv\", \"lundwall\", \"schweben\", \"karg\", \"kontinuierliche\", \"kanntes\", \"stimmauszahlung\", \"nebensaal\", \"wahlobmann\", \"tschirf\", \"zersplitterung\", \"rekord\", \"hochschulb\", \"beauf\", \"hauptlast\", \"eingespielt\", \"reitungen\", \"kandidieren\", \"glanzvoll\", \"einigkeit\", \"entgegnungen\", \"herausgeberin\", \"diskussien\", \"wortlich\", \"diaten\", \"erma\\u00dfigen\", \"administrativer\", \"stra\\u00dfburg\", \"nominierungen\", \"wieder\\u00e6ehenin\", \"austritte\", \"senntag\", \"raumliche\", \"verschlossen\", \"osesse\", \"ortes\", \"abliraungent\", \"mottos\", \"razumovsky_druck\", \"vertiefen\", \"osterr\", \"vereinigung\", \"mitglieder\", \"ehrenzeichen\", \"mitteilungen\", \"modifizieren\", \"sitzung\", \"bibliothekartag\", \"ausschusses\", \"deutsch\", \"ausschu\\u00df\", \"finden\", \"osterreichische\", \"vorsitzend\", \"wahren\", \"stellen\", \"konnen\", \"dicht\", \"arbeit\", \"berichten\", \"hofrat\", \"insbruck\", \"lokumentation\", \"statistische\", \"kammel_druck\", \"omuomesiv\", \"karg\", \"schweben\", \"kanntes\", \"wahlobmann\", \"kontinuierliche\", \"stimmauszahlung\", \"lundwall\", \"hochschulb\", \"tschirf\", \"nebensaal\", \"hauptlast\", \"beauf\", \"rekord\", \"eingespielt\", \"zersplitterung\", \"kandidieren\", \"reitungen\", \"herausgeberin\", \"glanzvoll\", \"einigkeit\", \"festsaales\", \"leidemann\", \"zuruf\", \"ohnedies\", \"ausgrabungen\", \"anhoren\", \"erwunschte\", \"nothiger\", \"noxit\", \"andoih\", \"glaow\", \"nachtung\", \"reimer\", \"ausklingen\", \"innbruck\", \"jahresbeitragen\", \"federhefer\", \"vorwegnehmen\", \"entschuldigung\", \"emnshark\", \"kanzleibe\", \"kassenrevi\", \"ostteiles\", \"ausleihevorgang\", \"tinger\", \"mahnungen\", \"anmeldekarten\", \"arbeitsdienst\", \"verspateter\", \"technisierung\", \"ausschu\\u00dfmitglie\", \"enelbroiif\", \"reference\", \"shnen\", \"efisgersbkesd\", \"einwenden\", \"amter\", \"handbuchereien\", \"oberrevicent\", \"lehre\", \"machungen\", \"ehelichung\", \"interessenge\", \"ausmachen\", \"osterr\", \"vereinigung\", \"mitglieder\", \"konnen\", \"zahlen\", \"deutsch\", \"ausschu\\u00df\", \"mitteilungen\", \"titel\", \"tagung\", \"stellen\", \"erscheinen\", \"berichten\", \"vorsitzend\", \"schriften\", \"erfolgen\", \"finden\", \"bibliothekartag\", \"wiener\", \"osterreichische\", \"gebeten\", \"fragen\", \"bericht\", \"bringen\", \"sitzung\", \"folgend\", \"wichtig\", \"fuhrung\", \"kommission\", \"statistik\"], \"Freq\": [182.0, 676.0, 209.0, 161.0, 139.0, 180.0, 182.0, 73.0, 150.0, 176.0, 132.0, 131.0, 181.0, 148.0, 614.0, 96.0, 161.0, 82.0, 184.0, 59.0, 89.0, 43.0, 120.0, 64.0, 45.0, 80.0, 207.0, 129.0, 149.0, 69.0, 23.798221188981515, 23.79094623350259, 19.995369983467146, 27.30477504178399, 16.22051529614152, 15.288250447768222, 15.278721238790508, 15.27740948361717, 16.931954126906422, 16.06332057148181, 14.333923991672613, 14.337299416165187, 13.399235150765607, 13.38106414039623, 18.522405906187135, 13.361377390223833, 12.455914186569807, 12.443218004545905, 21.58732559103965, 17.16499093245642, 15.455297481147548, 24.10098798122593, 22.211616827825555, 11.47100120306409, 11.43609973071376, 10.565406228317167, 10.564462241052812, 10.560036370164335, 10.559611278107594, 11.455311509376173, 13.758986612696754, 19.965378287148695, 28.586069503049607, 170.61600801774907, 45.27036842225866, 17.784904688868185, 18.834098887153644, 35.88256695001836, 16.842247046953567, 51.65480443282577, 30.42370598533441, 40.782081214977325, 24.569037414249895, 74.974154580838, 29.70318164938482, 128.710406263399, 114.82351384319888, 52.83388919417198, 217.35882683336627, 51.88534577677473, 73.12175378039335, 54.78545332554097, 45.18040673375343, 75.62650040442986, 31.60954457354358, 89.98291481822878, 41.66423582457797, 61.09060929529131, 51.66189178200295, 57.09056897724998, 137.81797156687156, 78.98227090348794, 62.59113214272265, 59.44746396824164, 64.661996014737, 89.26527604587275, 62.77972709990283, 47.99512363644594, 44.90343134118275, 42.757051465897824, 48.94193392896038, 48.834745217350125, 47.1635929495394, 45.07300957069679, 46.63841144187733, 19.22540583237971, 14.993882218657529, 17.283906859735644, 16.328727997783353, 13.618320721161371, 12.620008300991776, 12.595223607526973, 11.826534039515787, 11.826488530690494, 10.700929030923934, 10.156115724858044, 9.736563258369104, 11.524310664763346, 9.690706510767374, 8.79532184116922, 8.791808119448671, 8.787881882247248, 8.781004177521632, 8.783524779232172, 8.774172715634618, 11.22912647766498, 8.757726413384653, 8.757684574625916, 18.52971535619052, 16.660761855142145, 11.397785120251259, 7.83422095982245, 8.639792494679751, 7.829650258933825, 9.62043574642298, 17.99725035605836, 19.834937826104344, 14.490418084449502, 41.96455100162634, 17.81851811478965, 15.020551858305401, 24.27449696050357, 31.380311002831572, 11.504465880882687, 14.037722714921523, 12.793142956749538, 27.34307043638844, 34.36146789743655, 49.37416874936572, 84.51402840276045, 47.88826449882874, 25.74970076499039, 15.738284754228884, 32.61497424116972, 52.17620290762045, 129.39270033130967, 22.836896657947737, 56.07945081213701, 26.879150535306124, 179.51621446188415, 252.33181470029982, 259.472390145018, 59.81402832985432, 68.89068426095352, 71.11082789875547, 108.39529241207352, 36.65431702173603, 61.2079137356504, 74.89505994894648, 86.28411031079487, 83.268261011051, 50.49382678211052, 90.69102053311347, 60.25939824653687, 83.80718532832141, 70.84580798867944, 70.23731682583005, 47.06880323008426, 81.86478645535784, 57.3328401980696, 68.09096795027939, 59.23594880651311, 73.9484881270809, 67.17060921178215, 66.87827813442428, 65.64386152455869, 58.11646106485651, 61.23259419922501, 55.77181702526797, 39.525112354532894, 14.038619167134293, 14.757243158728665, 10.150615521825378, 10.108381308948214, 9.381630944718934, 10.82851213014371, 9.981815980462622, 8.628466287422393, 7.864383085524044, 7.864245178377507, 7.091953814757341, 7.091821877617147, 7.09191799471928, 7.091706059494082, 7.091660090445236, 6.319312011764806, 6.31926604271596, 6.319244550693123, 6.3191490305916265, 6.317548471890907, 6.314898983075618, 6.314118703246509, 6.309028078837321, 6.3077021404284075, 6.308402422172511, 6.307296776997677, 6.306347545989045, 6.301262294585566, 5.54701229013576, 8.557589178109904, 123.88295209935609, 15.4608824344006, 19.655582021598015, 10.181849401013826, 7.835232141548879, 51.116163842934505, 24.65306716781807, 9.277392245957138, 16.855030553792357, 21.071509918132495, 25.691750363500457, 7.8480264621438485, 23.15751371467519, 28.115119218519997, 21.8344838928522, 22.187944088431394, 16.688839905201753, 33.494247766266106, 10.376599365950943, 20.195418651216787, 24.20224810878745, 18.406370134212377, 38.60601793792297, 25.904764965845185, 16.192907896235084, 50.967271884725115, 17.024415155776786, 53.079679825324284, 17.232515248899464, 20.24411241095773, 25.469850003713915, 17.80799042838699, 32.84401377934148, 24.998004582341135, 21.84081926358403, 22.621655497283793, 20.564665931570993, 21.904531171282933, 20.12123057638614, 18.22782276649179, 19.404894291222632, 19.186087588723346, 16.840176353432867, 16.17580203665462, 13.47230566905137, 13.13687170649067, 12.487222224880895, 12.721020798806665, 12.574839104011996, 11.068779789772096, 9.773594528393717, 9.446454874517427, 9.442156706027706, 9.442849650691938, 9.114128171409714, 9.111055320243503, 9.41768954677302, 8.76143367410233, 8.389381648126438, 8.442392392832975, 8.10817705709558, 8.106108736746068, 8.105458802440305, 8.105458802440305, 8.105458802440305, 8.09802756828252, 7.735294931201225, 7.72901111782883, 11.27211078154381, 7.3911719204439414, 7.931585605184354, 6.738607292315678, 23.938701493814445, 10.514065638733443, 27.71678108263449, 24.358494061905745, 26.409719227604068, 25.48304098287795, 20.31141239864551, 14.456866298420003, 13.664928037349922, 20.1820582676556, 63.25087641639294, 34.90886235475894, 20.10632371689101, 64.6105580997607, 34.50493200687119, 53.790960255460305, 33.12671954950328, 46.42888293094949, 122.12527108236534, 24.80772674247655, 18.559501096465194, 42.2554291882199, 38.47813716685272, 28.7361839255064, 27.8524835425345, 28.66189834592936, 29.187165693988298, 27.969400989426518, 28.67758278998457, 22.73078138241346, 23.810981756446377, 33.85409543936766, 38.10062856006566, 32.30864341569841, 29.237086383385236, 43.41329097707684, 34.06627987448389, 31.9935514411223, 37.26721015350184, 30.301512469503024, 29.62713107598754, 28.676770372102368, 27.024740591717173, 16.961239199631358, 14.175278332002149, 11.400741505048966, 11.157980462527995, 11.389904664766993, 11.5627012079098, 10.401073453620567, 8.83622644816102, 8.369923774074872, 8.602369615498878, 8.331269740368372, 6.512230525493452, 6.940813413101985, 7.385978298245944, 6.053118205747089, 6.0477193827066325, 5.834749496099901, 5.833589347748546, 5.82673107518501, 5.826638078035224, 5.820450738931639, 5.825903364920822, 5.823872748995032, 6.473803105531259, 5.8234376933632745, 5.595789578459843, 5.595789578459843, 5.595057003210952, 5.594579546579866, 5.594161237561289, 12.690448069559716, 49.54067200247267, 7.2385347022137925, 6.016294184919139, 7.4763807919219305, 12.681919411409217, 19.793638781919274, 34.16896004039697, 30.253784310132716, 9.012880413309896, 15.076238994861018, 11.608259121977433, 14.110176051420847, 17.848514672724, 21.31126817705179, 15.287455831747645, 37.53261207627912, 25.87897319569342, 23.178207693974013, 28.37562955073284, 11.263333762353502, 17.362495177639524, 19.81791923316458, 28.822728491543614, 48.59035942688362, 30.621961807690525, 18.511311416535232, 17.98327146218418, 33.27644394631178, 28.902425267355717, 24.543003934117806, 27.44906723574205, 20.930448768097772, 23.64689765121559, 47.17384964524038, 29.394083026418034, 27.05642685574855, 27.28936013050937, 21.050147858132814, 20.514633925950676, 21.76049358142549, 24.44607311178902, 28.569015164003005, 22.2689763420698, 20.073131917051168, 21.420273663794188, 20.798760528269614, 11.456089659294207, 9.419486151763811, 9.065867245435891, 8.672164083155964, 8.672164083155964, 8.672164083155964, 8.672164083155964, 6.7776435786412135, 6.1622275365397945, 6.161760884934005, 5.806171740775795, 7.127093027337095, 5.802630897607405, 6.1116423783628475, 5.796028273823376, 5.7867678457473355, 5.409944812431052, 5.431176219399734, 6.039205886416444, 5.699816130780986, 5.098135283682923, 5.097444614484461, 5.093083407721853, 5.095577387513959, 5.092609309547886, 5.049404320982167, 4.742938945996074, 4.741857952515644, 4.7418176169380155, 4.741745943719308, 11.533319258957514, 5.074360873681632, 5.738645019447741, 7.7971557100089255, 8.994963505439353, 17.700064380191645, 15.75423640038673, 9.105352673196961, 8.031473147565492, 6.2409625840696465, 12.255383188854708, 9.716862990289295, 10.99328792925343, 9.752647473666158, 13.375499697394826, 10.073439425278368, 13.5567839174861, 9.264670758259376, 17.11276844117042, 28.402807076675078, 9.501992265528207, 20.60565943378168, 9.461670960489217, 30.545557069743964, 17.12452781341735, 54.048283995457766, 10.423596918498458, 22.887240761762044, 23.043521888102745, 42.55862644791419, 17.67390086290008, 26.641792990277562, 17.067382849223396, 24.675283408454405, 22.119065199520524, 17.327400875749827, 11.787295636502618, 16.818140006849774, 12.850063641318595, 15.841959455706798, 16.727480521478387, 12.152666468509292, 16.680358638051317, 17.239494138414717, 17.591680821463168, 14.977160948078428, 14.292484995905648, 13.632397611854893, 13.742944398638926, 13.42188685276172, 2.993008988750978, 2.8804847831872205, 2.762280149763689, 2.762280149763689, 2.762280149763689, 2.762280149763689, 2.9677115041999955, 3.8730167093385894, 5.409857703468339, 1.8367822190292291, 2.776913434842077, 1.615816976120729, 1.5066886605938958, 1.50412473888266, 1.5039322309138274, 1.5028382951059265, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 1.391481400978447, 4.994500119023667, 1.498070115929293, 2.7598451506804027, 33.98840891408535, 2.3909685534769887, 2.8317021508839124, 4.607303523638535, 2.9985177258848017, 10.485019485878166, 7.306573589201076, 2.9644996715679612, 2.7514143734243723, 2.8659013770472237, 3.212555876640718, 4.74919508779243, 2.451768093817612, 2.503553355767552, 4.151192373192351, 4.896413392788414, 5.018410268308897, 4.104136335380383, 4.785426983750845, 5.382623390884037, 4.9613710228112975, 5.370473128825485, 4.5774260395421225, 4.006757395403129, 3.7839378720432335, 3.336690744838611, 3.354630467642924, 3.2894990857809345, 3.3175543397355374, 2.9920656172591715, 3.240183449615312, 3.310871180325045, 3.1005809577332117, 3.039954344786433, 0.6697310820372302, 0.2604701629123983, 0.2597530075463296, 0.3348883023397429, 0.17855538255848805, 0.17855364505305846, 0.17855182067235736, 0.17854904066367, 0.17854072959603173, 0.17853894865296638, 0.1785246576708079, 0.17847277865452232, 0.17722816007766187, 0.25858273972264423, 0.1760854896318834, 0.177124865379872, 0.17697300740532468, 0.16836986510434016, 0.25985271139956495, 0.17350787136864335, 0.09651763025779767, 0.096517405830013, 0.096517239319076, 0.09651696421404965, 0.096516906297202, 0.09651697869326156, 0.09651682666153648, 0.09651675426547691, 0.09651661671296373, 0.09651608098212294, 0.2500645324787435, 0.33763891822692377, 1.132777553197108, 0.1701067334486191, 0.1772194001544543, 0.20692574767255742, 0.17148577702888315, 0.21386948541299947, 0.1678457465915004, 0.14786463686003137, 0.15496004434526586, 0.04131095252846723, 0.022929467574425606, 0.02292906692747603, 0.022929018462119227, 0.022928806830061186, 0.022928789059430358, 0.022928706668323792, 0.02292852734650362, 0.022928417491694865, 0.02292823170782712, 0.022928115390970793, 0.022927974841436063, 0.02292707338579952, 0.022926189700793805, 0.022837039292465833, 0.02283679373465803, 0.022834585329899685, 0.022833128138171798, 0.02283247870239063, 0.02283179372534781, 0.022831047358853038, 0.022830796954509555, 0.022946472452616027, 0.02282970325295769, 0.0228298244163497, 0.022827574008282128, 0.02293645304785287, 0.02282588741386537, 0.02282448191851807, 0.022822738781185042, 0.022934252720653997, 0.032491685702761265, 0.03272454318104117, 0.032724251023108566, 0.017654529454925693, 0.01765433385766573, 0.01765439699349015, 0.017654367282513954, 0.01765426700796929, 0.017654198920315504, 0.017654092455984132, 0.01765357375185803, 0.01765354775475386, 0.017653478429142732, 0.017653441290422487, 0.017653339777920482, 0.01765328035596809, 0.01765328035596809, 0.01765332368447504, 0.017653238265418477, 0.017653334826091115, 0.017653097138281542, 0.017652678708700104, 0.01765197431097277, 0.01765190869923367, 0.01765178985532888, 0.01765050733152305, 0.032723864780418006, 0.017652956011144607, 0.017652896589192214, 0.017654851323834493, 0.011263360512639282, 0.01667014291565856, 0.02924684618214395, 0.035149164339618934, 0.017653722306739016, 0.0035421735472103053, 0.0035420666546092557, 0.003540896330477202, 0.003540027952968207, 0.003532551215123288, 0.003514659191900855, 0.003542678290076477, 0.0005619156101009855, 0.0005619137994202435, 0.0005619157349755194, 0.0005619157349755194, 0.0005619171710326597, 0.000561930532607791, 0.0005619270985581077, 0.0005619262244363701, 0.0005619288468015828, 0.0005619282224289131, 0.0005619266614972388, 0.0005619275980562435, 0.0005619247259419629, 0.0005619251005655647, 0.0005619239766947592, 0.0005619289716761167, 0.0005619247883792298, 0.0005619224157630851, 0.0005619202928960082, 0.0005619209172686778, 0.0005619258498127683, 0.0005619212918922796, 0.0005619270361208407, 0.0005619249756910308, 0.0005619287219270488, 0.000561922540637619, 0.0006076263703093397, 0.0005619408971941077, 0.0005619395860115014, 0.0005619375880189584, 0.0005619350280910126, 0.0005619420210649131, 0.0005619330300984696, 0.0005619345285928769, 0.0005619318437903973, 0.0005654612976175808, 0.0005619376504562253, 0.0005619370885208226, 0.0005619396484487683, 0.0005639507528178169, 0.0005619389616388316, 0.0005619345285928769, 0.0005619378377680263, 0.0005619337169084064, 0.0005714444735993512, 0.0005708778554016139, 0.0005668939207081682, 0.0005658853090975625, 0.0005654644819181962, 0.0005653562781345402, 0.0005652734863185402, 0.0005649642345352462, 0.0005647984011541785, 0.0005647960285380337, 0.0005647056818127305, 0.0005646710291295631, 0.0005645695061334727, 0.0005645423459223415, 0.0005643885629337986, 0.0005643464802158619, 0.0005643448568469208, 0.0005642797347774729, 0.0005641941332844594, 0.0005640812467057807, 0.0005640794984623056, 0.00011385912097147453, 0.00011385860353591202, 0.0001138590452491971, 0.00011385896952691965, 0.00011385881808236477, 0.00011385857829515289, 0.00011385846471173672, 0.00011385881808236477, 0.00011385905786957667, 0.00011385845209135715, 0.0001138579598965538, 0.00011385761914630532, 0.00011385865401743032, 0.00011385825016528398, 0.00011385797251693336, 0.00011385843947097757, 0.0001138580987207291, 0.00011385827540604312, 0.00011385804823921081, 0.00011385713957188154, 0.00011385788417427635, 0.00011385782107237848, 0.00011385850257287544, 0.00011385871711932819, 0.0001138586161562916, 0.00011385846471173672, 0.0001138580987207291, 0.00011385850257287544, 0.0001138577705908602, 0.00011385748032213, 0.00011385872973970775, 0.00011385898214729923, 0.00011385980247197149, 0.00011385968888855533, 0.00011385939861982515, 0.00011385953744400045, 0.00011385980247197149, 0.00011385903262881752, 0.0001138595626847596, 0.00011385908311033582, 0.00011386241489054315, 0.00011386240227016358, 0.00011386237702940443, 0.00011386199841801723, 0.00011386235178864528, 0.00011386209938105382, 0.0001138618217327032, 0.00011386172076966662, 0.00011386222558484955, 0.0001138619226957398, 0.00011386175863080534, 0.00011386159456587089, 0.00011386159456587089, 0.00011386151884359345, 0.00011386160718625046, 0.00011386151884359345, 0.00011386153146397302, 0.00011386155670473217, 0.00011386150622321387, 0.00011386151884359345, 0.00011386139263979772, 0.00011386124119524284, 0.00011386114023220626, 0.00011386126643600199, 0.00011386126643600199, 0.00011386120333410412, 0.00011386122857486326, 0.00011386114023220626, 0.00011386112761182668, 0.00011519144182264375, 0.00011494489008730059, 0.0001148747081564937, 0.0001147251566585506, 0.00011467883986551675, 0.0001144739101420062, 0.00011443794206022241, 0.00011437539545905735, 0.00011436951436217621, 0.00011430051874704921, 0.00011428436466119544, 0.00011427930388898656, 0.00011427551777511459, 0.00011426908138153222, 0.0001142671126023188, 0.00011426535836955811, 0.00011426479045247732, 0.00011424982268230344, 0.00011424934310787966, 0.00011422894857448927, 0.00011420387188027721, 0.00011419417942876495, 0.0001141846636625667, 0.00011417926214010935, 0.00011417802534291118, 0.00011416729802027391, 0.00011416492538891414, 0.00011416018012619459, 0.00011415826182849945, 0.00011415216618516556], \"Total\": [182.0, 676.0, 209.0, 161.0, 139.0, 180.0, 182.0, 73.0, 150.0, 176.0, 132.0, 131.0, 181.0, 148.0, 614.0, 96.0, 161.0, 82.0, 184.0, 59.0, 89.0, 43.0, 120.0, 64.0, 45.0, 80.0, 207.0, 129.0, 149.0, 69.0, 24.32614468113319, 24.321290258073084, 20.53048291042851, 28.07863380824995, 16.755510500681385, 15.816569589027905, 15.809677405776556, 15.809420439762857, 17.55099410616102, 16.658015660137945, 14.864701321575529, 14.870359486674188, 13.928028837287611, 13.915783075281318, 19.274617819329062, 13.90409570150269, 12.983752425313487, 12.975386293664942, 22.549044083198947, 17.934439774593542, 16.157205184510072, 25.23081523631362, 23.2814328771007, 12.024603316987335, 11.99238184181416, 11.092898191092647, 11.092216036630045, 11.089183227238435, 11.090200148635837, 12.034217080917916, 14.507658272432023, 21.303778851499953, 30.987186309650628, 203.0754130486512, 51.22096651316781, 19.1593987763893, 20.58172380845716, 42.078703352130645, 18.35665907703689, 68.10367589345613, 36.653027463081294, 52.67414756373135, 29.062736875661024, 113.34942439845508, 37.38554371731049, 258.3346114824959, 223.61916014353278, 84.96136398977232, 614.2637775956865, 84.92308574231664, 138.1891303571665, 94.75766433063416, 72.67525138457938, 155.40844981925207, 43.71977986291535, 209.8219752400849, 67.1913758162418, 129.5792411677665, 102.95878055378557, 125.55563869144088, 676.8406352599028, 245.72526342571962, 163.69803132506755, 151.7702232033179, 184.47606425450198, 386.1350018129594, 187.49592773671506, 104.892076838173, 92.43170141170826, 83.18568334141982, 148.69490410805446, 148.11472554285507, 190.4247546423511, 134.72165526358745, 192.39872629098747, 19.821969150140248, 15.527972265620429, 17.914836824424796, 16.951343690810805, 14.143199407104493, 13.147053822530456, 13.130634618075854, 12.353166270173684, 12.353301439438205, 11.230524411281262, 10.684422741396814, 10.273672017709972, 12.186746470825032, 10.253669729058705, 9.320098431781666, 9.317122133705809, 9.315272778247435, 9.308924239090372, 9.313198290561221, 9.305552697810674, 11.91514086411004, 9.294939836450409, 9.29505699718024, 19.68975395391296, 17.724211833313316, 12.159405920132642, 8.359447745561058, 9.220290390180512, 8.355993098014459, 10.26905884273109, 19.23041659725545, 21.24983688970877, 15.806075725419252, 48.75640564260796, 19.695509637700138, 16.433839742528043, 27.436378127947446, 36.54018219478814, 12.440800851383008, 15.417926106813221, 13.952833454844875, 32.007948854255226, 41.78076396896345, 62.95792302031739, 116.39191849217015, 61.90532415567787, 30.688559260690468, 17.618376780189976, 41.94986039871775, 73.61635904192795, 217.29871167307542, 27.664263068459288, 83.84266287686056, 34.22033692439011, 386.1350018129594, 614.2637775956865, 676.8406352599028, 101.30865719778086, 123.13499964089651, 132.38985851656415, 245.72526342571962, 54.00744590612729, 111.64485808522664, 149.27698227101686, 182.9784984119048, 176.58956885886468, 86.27878743510166, 207.0370834844417, 114.10409025107697, 190.4247546423511, 148.11472554285507, 148.69490410805446, 80.96137632201224, 209.8219752400849, 116.94445160009424, 163.0004334148375, 129.4692302559722, 223.61916014353278, 181.83180147004194, 187.49592773671506, 192.39872629098747, 151.7702232033179, 258.3346114824959, 163.69803132506755, 40.088696555443484, 14.598411050633313, 15.365320656583272, 10.713500104448297, 10.702822429735978, 9.947392787957611, 11.522450393277984, 10.624517834955972, 9.188538450611674, 8.423235333602388, 8.423114373489197, 7.65076178199968, 7.650624107567788, 7.650753082403663, 7.650528957934369, 7.650487369588158, 6.87809747044311, 6.878075784816066, 6.878065423755295, 6.877974174395793, 6.876450140927335, 6.873922955703491, 6.873497799762593, 6.867958719053845, 6.866900099493758, 6.867952418101128, 6.867081951123833, 6.866450574201417, 6.865245666989663, 6.105791958178604, 9.506478661681138, 161.24633909296648, 18.085772129362578, 23.68352978528875, 11.674946267585625, 8.755957380887859, 72.58990442444885, 34.366267406004056, 10.931165942131718, 23.415696834110708, 31.03202766762903, 41.11432771695281, 9.120828790655578, 40.908456729197695, 70.77127622793671, 48.4206475187077, 49.85268783550103, 31.525900130180716, 104.892076838173, 14.454540473454049, 45.412398679613844, 63.838488178420185, 40.05861098199771, 182.9784984119048, 87.00608686961213, 34.07916142967284, 386.1350018129594, 39.807555171468046, 676.8406352599028, 48.601754675139446, 80.73605773797271, 182.13705283149014, 64.0667002197132, 614.2637775956865, 245.72526342571962, 149.27698227101686, 190.4247546423511, 120.56273306981159, 187.49592773671506, 161.05721193445987, 78.35569463118314, 217.29871167307542, 258.3346114824959, 17.48707175255988, 16.815249428988757, 14.12038399875833, 13.8001800348294, 13.127719005850176, 13.39880242723713, 13.349168249163037, 11.758457437444767, 10.417133923210145, 10.088206802379375, 10.08457977039925, 10.100136451269423, 9.759984703944799, 9.766754529012418, 10.117465874542043, 9.4215215813972, 9.028984730829539, 9.09106303267648, 8.747585710562825, 8.745535782346066, 8.745004810208467, 8.745004810208467, 8.745004810208467, 8.737495625405513, 8.375980210095479, 8.372167683418638, 12.239985638359478, 8.039449213895699, 8.685861420052696, 7.381717901875475, 26.892068956400117, 11.748811226926117, 34.57581329330809, 31.83047523918981, 35.36831062860668, 36.833943986821794, 29.718545950942183, 19.25910978499106, 17.87642913442465, 31.043568624096686, 161.05721193445987, 71.61796973828481, 32.26419148208125, 180.5475354549846, 72.03692282845067, 150.0504208321301, 72.1094322844599, 127.63150696931027, 676.8406352599028, 49.58830159086001, 30.705404428008016, 139.99785927821782, 120.0210322226963, 73.2225848227785, 70.91455176756935, 76.33448886905289, 80.61758230950151, 73.59940717845325, 80.73605773797271, 48.65669377281134, 55.40626654556123, 131.18691217328134, 181.83180147004194, 119.9766067672626, 106.41658078122623, 386.1350018129594, 192.39872629098747, 190.4247546423511, 614.2637775956865, 207.0370834844417, 184.47606425450198, 182.13705283149014, 108.30805228384345, 17.619685029258527, 14.84019654717697, 12.058959982493755, 11.816814652891798, 12.065419569630508, 12.31660193487924, 11.128044003809036, 9.498788761726138, 9.028909687638588, 9.281986924712541, 9.04217996722501, 7.178376441285978, 7.657642427546501, 8.186896286069768, 6.717989808217376, 6.726983950033404, 6.493538767513667, 6.492466546364219, 6.485422427363902, 6.485509227573474, 6.478971682065785, 6.48810958076151, 6.488537185736924, 7.216992874720546, 6.497983390976383, 6.2539834806373715, 6.2539834806373715, 6.25327479377799, 6.252818228606395, 6.252408161110216, 14.505211206496124, 59.45126083822633, 8.17820874262901, 6.744450634881271, 8.534215713750495, 15.128820149581077, 24.577070352943853, 45.82146504302996, 40.90307993137851, 10.883428518899144, 20.287231425869862, 14.915624984755842, 19.056420157850773, 25.9572223463219, 33.63598595245503, 22.06220757319466, 80.61758230950151, 51.890099361598374, 48.533475306935735, 67.90386661683085, 16.153079103480426, 31.924339361084858, 39.468948278884135, 73.59940717845325, 180.5475354549846, 89.76317668044639, 36.94903766296824, 35.8658237045816, 139.99785927821782, 120.0210322226963, 82.39413791795349, 114.10409025107697, 60.06874778941764, 88.70387838416634, 676.8406352599028, 176.58956885886468, 161.05721193445987, 182.13705283149014, 73.2225848227785, 72.1094322844599, 96.0334213213867, 192.39872629098747, 614.2637775956865, 150.3977665817704, 81.47646994266682, 181.83180147004194, 184.47606425450198, 12.220610960755854, 10.056626046865162, 9.702775800363446, 9.307387470221052, 9.307387470221052, 9.307387470221052, 9.307387470221052, 7.474417721902322, 6.797940364970243, 6.798342938706555, 6.441655075894833, 7.908371256284928, 6.439987521626265, 6.783390534832059, 6.447666943707517, 6.456708753580034, 6.045168576964754, 6.083844054521372, 6.772732357033421, 6.409502115214864, 5.7337877753435045, 5.733309654619672, 5.730130168477288, 5.7329645836012695, 5.732837437734458, 5.684750890828652, 5.3780621119300465, 5.376988599424748, 5.377012554211343, 5.376979443453231, 13.098360105839912, 5.758722995971539, 6.531498474820364, 8.980624120688047, 10.73572961181782, 22.845882159494813, 20.727465458871748, 11.530724824982792, 10.05057414644177, 7.369639092033104, 17.637443173244712, 13.351646472611005, 16.876358657579413, 14.222224902442933, 23.112371140547218, 15.211555907035974, 24.406509512427828, 13.744847642546404, 37.92906021167902, 91.3983035567837, 14.703594663594506, 56.22190034155197, 14.864994326827093, 139.99785927821782, 50.1622754495332, 676.8406352599028, 18.461385051864585, 120.0210322226963, 123.13499964089651, 614.2637775956865, 69.87692826122124, 207.0370834844417, 66.38848475568902, 187.49592773671506, 163.0004334148375, 80.73605773797271, 25.371701637506725, 88.70387838416634, 35.68674514778388, 80.3299239638859, 106.02360879890692, 32.190433958139735, 127.63150696931027, 176.58956885886468, 258.3346114824959, 106.8822347749538, 161.05721193445987, 149.27698227101686, 182.13705283149014, 120.56273306981159, 3.6727062705924842, 3.5599186404061354, 3.441811335414605, 3.441811335414605, 3.441811335414605, 3.441811335414605, 3.6979754846866557, 5.0818535789720976, 7.215855405377647, 2.557236208212552, 3.894049844811556, 2.3202031874725826, 2.1870928848569093, 2.1872163024720823, 2.199090258714296, 2.2108018399316887, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 2.0708754396871645, 7.641923908183943, 2.242114561420438, 5.303500184411775, 182.13705283149014, 4.763581576827173, 6.39339128631837, 13.84544006323028, 7.744452888205041, 73.2225848227785, 43.52212464530096, 8.396908204874261, 8.062495798389062, 10.029535701883974, 13.708397872659045, 36.32491618102516, 7.492586059997258, 8.013131186504864, 31.924339361084858, 56.59554689064939, 64.91550609381538, 45.80052432304263, 96.0334213213867, 182.9784984119048, 139.99785927821782, 209.8219752400849, 150.3977665817704, 69.87692826122124, 131.18691217328134, 82.39413791795349, 184.47606425450198, 132.38985851656415, 181.83180147004194, 21.241679237408295, 176.58956885886468, 614.2637775956865, 676.8406352599028, 180.5475354549846, 1.3554821240621144, 0.9457409742983187, 0.9450316065235899, 1.3745397291548949, 0.8636883484396901, 0.8636910931642205, 0.8636870348278968, 0.863692805791351, 0.8637195280683535, 0.8637268347034849, 0.8637539533248104, 0.863900111549252, 0.8625628280377794, 1.3023291774041645, 0.979996398243635, 1.2113460079604037, 1.2203810843031828, 1.2138274545828902, 1.8899416909897422, 1.323376797376766, 0.781600106166469, 0.7816003812296185, 0.7816007665919472, 0.7816005975877487, 0.781600165408759, 0.781601816195889, 0.781600746346001, 0.7816017983152918, 0.7816021690716914, 0.7816009102009328, 2.059698919386335, 3.21940086911885, 35.36831062860668, 1.8864381909535088, 2.7734339580968927, 4.342150686966689, 2.8911871768042947, 5.12917495402881, 3.558607917415235, 3.0791896941282024, 16.157205184510072, 1.1028536556681825, 0.7194357435528226, 0.719436057042444, 0.7194385447928927, 0.7194399487056509, 0.7194393983875679, 0.7194385442344644, 0.7194394743922432, 0.719438413332782, 0.7194422001435022, 0.7194420546397658, 0.7194392612890531, 0.7194431836619228, 0.719447355422931, 0.7193777545796495, 0.7193761333347404, 0.7193815426362474, 0.7193756217862828, 0.7193773537657693, 0.7193824029921609, 0.7193814311366228, 0.7193745858728222, 0.7230509593827015, 0.7193860717501178, 0.7194032761262128, 0.7193982546350115, 0.7228617413313221, 0.719406865607003, 0.71939736632671, 0.7193802306608907, 0.7298781948253295, 4.044416387278087, 0.7300577999647253, 0.7300619649480091, 0.71498048597808, 0.7149776206589957, 0.7149805637489758, 0.714980213362819, 0.7149795502347083, 0.714979217185809, 0.7149795863193009, 0.7149788093348707, 0.7149794510744172, 0.7149800960907509, 0.7149799992861879, 0.7149790994932741, 0.7149782496018039, 0.714978819087823, 0.7149806492296357, 0.7149790677326697, 0.7149848207267794, 0.7149780991747698, 0.7149809138567058, 0.7149817940283469, 0.7149810927428493, 0.714979895523324, 0.7149768319099646, 1.793941296899934, 1.0658543532572426, 1.1663699786303707, 1.4828009949992575, 1.1558432624820052, 1.7206008503879908, 3.8155572527642896, 9.130189353357276, 3.1149605159446474, 0.7031174656409243, 0.7031189109123877, 0.7031496524176201, 0.7031728711290816, 0.7034376618333125, 0.7041615226004176, 1.4469727870844362, 0.7018944688071959, 0.7018944160577597, 0.7019472369987277, 0.7019520181731146, 0.7020485703145298, 0.7021438684387219, 0.7021446429387537, 0.7021441191121994, 0.7021474515685073, 0.7021469458059433, 0.7021456512707764, 0.7021512601307226, 0.7021507220296638, 0.7021526309530768, 0.7021524690767449, 0.7021589094008814, 0.7021541929257612, 0.7021558592144415, 0.7021559516631788, 0.7021575878238038, 0.7021660997689985, 0.7021629205515243, 0.7021757313716367, 0.702175365689586, 0.7022086825799363, 0.7021720188734282, 2.5548629055936223, 0.7025308206616387, 0.7025746317750567, 0.7025438975860354, 0.7024774137649438, 0.70271364857756, 0.7024588844948729, 0.7025580672347336, 0.7024479285487686, 0.921007810581712, 0.7026949944126799, 0.7027713767057457, 0.7029489499236499, 0.9212263528996429, 0.7029468079771506, 0.7027109831821028, 0.7031802346368862, 0.7027505684479397, 614.2637775956865, 676.8406352599028, 386.1350018129594, 3.3004361649752596, 258.3346114824959, 1.6898094049441348, 180.5475354549846, 161.05721193445987, 120.56273306981159, 223.61916014353278, 182.9784984119048, 184.47606425450198, 150.3977665817704, 217.29871167307542, 125.55563869144088, 209.8219752400849, 245.72526342571962, 2.4144595651430394, 149.27698227101686, 181.83180147004194, 151.7702232033179, 0.7018944688071959, 0.7018944160577597, 0.7019472369987277, 0.7019520181731146, 0.7020485703145298, 0.7021441191121994, 0.7021446429387537, 0.7021469458059433, 0.7021507220296638, 0.7021474515685073, 0.7021456512707764, 0.7021438684387219, 0.7021541929257612, 0.7021526309530768, 0.7021512601307226, 0.7021559516631788, 0.7021558592144415, 0.7021589094008814, 0.7021575878238038, 0.7021524690767449, 0.7021629205515243, 0.7021660997689985, 0.7021720188734282, 0.7021757313716367, 0.702175365689586, 0.7021797958163482, 0.702180252815026, 0.7021925152753064, 0.7021903925287811, 0.7022022307268008, 0.7022266674853515, 0.7022318832741283, 0.7022865321506263, 0.7022990757769464, 0.7022891209187274, 0.7023222565181214, 0.702358650302235, 0.7022893890128877, 0.7023732928896756, 0.702340067026068, 0.7031221013578001, 0.703163091798617, 0.703160753459263, 0.7031214839359012, 0.7032524022779875, 0.7032212028782681, 0.7031500400445939, 0.7031227412847589, 0.7032811053781278, 0.7032015783825354, 0.7031526373297746, 0.7031299833799671, 0.7031352207593453, 0.7030976012120831, 0.7031581581961324, 0.7031213265362322, 0.7031704294286482, 0.7031877711428365, 0.7031942799435308, 0.7032194007956154, 0.7031990856481402, 0.7031293059891055, 0.7030717662232047, 0.7031579717856563, 0.7031659888933356, 0.7031288434804871, 0.7031450236067157, 0.7031038663395077, 0.7031106853601641, 614.2637775956865, 676.8406352599028, 386.1350018129594, 245.72526342571962, 161.24633909296648, 223.61916014353278, 182.9784984119048, 258.3346114824959, 203.0754130486512, 190.4247546423511, 209.8219752400849, 187.49592773671506, 181.83180147004194, 217.29871167307542, 104.892076838173, 163.69803132506755, 184.47606425450198, 161.05721193445987, 155.40844981925207, 150.3977665817704, 150.0504208321301, 192.39872629098747, 207.0370834844417, 148.11472554285507, 180.5475354549846, 176.58956885886468, 138.1891303571665, 91.3983035567837, 182.13705283149014, 72.58990442444885], \"Category\": [\"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Default\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic1\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic2\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic3\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic4\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic5\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic6\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic7\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic8\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic9\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic10\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic11\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\", \"Topic12\"], \"logprob\": [30.0, 29.0, 28.0, 27.0, 26.0, 25.0, 24.0, 23.0, 22.0, 21.0, 20.0, 19.0, 18.0, 17.0, 16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, -6.9799, -6.9803, -7.1541, -6.8425, -7.3633, -7.4225, -7.4231, -7.4232, -7.3204, -7.373, -7.4869, -7.4867, -7.5544, -7.5557, -7.2306, -7.5572, -7.6274, -7.6284, -7.0775, -7.3067, -7.4116, -6.9673, -7.0489, -7.7097, -7.7128, -7.792, -7.7921, -7.7925, -7.7925, -7.7111, -7.5279, -7.1556, -6.7966, -5.0101, -6.3369, -7.2712, -7.2139, -6.5693, -7.3257, -6.205, -6.7343, -6.4413, -6.9481, -5.8324, -6.7583, -5.292, -5.4062, -6.1824, -4.768, -6.2005, -5.8574, -6.1461, -6.3389, -5.8238, -6.6961, -5.6499, -6.4199, -6.0372, -6.2048, -6.1049, -5.2236, -5.7803, -6.0129, -6.0645, -5.9804, -5.6579, -6.0099, -6.2785, -6.345, -6.394, -6.2589, -6.2611, -6.2959, -6.3413, -6.3071, -7.1792, -7.4278, -7.2856, -7.3425, -7.524, -7.6001, -7.6021, -7.6651, -7.6651, -7.7651, -7.8173, -7.8595, -7.691, -7.8642, -7.9612, -7.9616, -7.962, -7.9628, -7.9625, -7.9636, -7.7169, -7.9655, -7.9655, -7.216, -7.3224, -7.702, -8.0769, -7.979, -8.0775, -7.8715, -7.2452, -7.148, -7.4619, -6.3986, -7.2552, -7.426, -6.946, -6.6892, -7.6927, -7.4937, -7.5865, -6.8269, -6.5985, -6.236, -5.6985, -6.2665, -6.887, -7.3793, -6.6506, -6.1808, -5.2726, -7.007, -6.1086, -6.8441, -4.9451, -4.6047, -4.5768, -6.0442, -5.9029, -5.8712, -5.4496, -6.5339, -6.0211, -5.8193, -5.6778, -5.7133, -6.2136, -5.628, -6.0368, -5.7069, -5.8749, -5.8835, -6.2838, -5.7303, -6.0865, -5.9146, -6.0539, -5.832, -5.9282, -5.9325, -5.9512, -6.073, -6.0207, -6.1141, -5.5587, -6.5938, -6.5439, -6.9181, -6.9223, -6.9969, -6.8535, -6.9349, -7.0806, -7.1733, -7.1733, -7.2767, -7.2767, -7.2767, -7.2767, -7.2767, -7.392, -7.3921, -7.3921, -7.3921, -7.3923, -7.3927, -7.3929, -7.3937, -7.3939, -7.3938, -7.3939, -7.3941, -7.3949, -7.5224, -7.0888, -4.4163, -6.4973, -6.2573, -6.915, -7.177, -5.3016, -6.0308, -7.0081, -6.411, -6.1877, -5.9895, -7.1754, -6.0933, -5.8993, -6.1522, -6.1361, -6.4209, -5.7243, -6.8961, -6.2302, -6.0492, -6.323, -5.5822, -5.9812, -6.4511, -5.3045, -6.401, -5.2639, -6.3889, -6.2278, -5.9982, -6.356, -5.7439, -6.0169, -6.1519, -6.1167, -6.2121, -6.149, -6.2339, -6.3327, -6.2701, -6.2815, -6.1894, -6.2296, -6.4125, -6.4377, -6.4884, -6.4699, -6.4814, -6.609, -6.7334, -6.7675, -6.7679, -6.7679, -6.8033, -6.8036, -6.7705, -6.8428, -6.8862, -6.8799, -6.9203, -6.9205, -6.9206, -6.9206, -6.9206, -6.9215, -6.9673, -6.9681, -6.5908, -7.0128, -6.9423, -7.1053, -5.8376, -6.6604, -5.6911, -5.8202, -5.7394, -5.7751, -6.0019, -6.342, -6.3983, -6.0083, -4.866, -5.4604, -6.0121, -4.8447, -5.472, -5.028, -5.5128, -5.1752, -4.2081, -5.802, -6.0921, -5.2694, -5.363, -5.655, -5.6862, -5.6576, -5.6394, -5.682, -5.657, -5.8894, -5.843, -5.4911, -5.3729, -5.5378, -5.6377, -5.2424, -5.4848, -5.5476, -5.395, -5.6019, -5.6244, -5.657, -5.7164, -5.8886, -6.068, -6.2859, -6.3074, -6.2868, -6.2718, -6.3776, -6.5407, -6.5949, -6.5675, -6.5995, -6.8459, -6.7821, -6.72, -6.919, -6.9199, -6.9557, -6.9559, -6.9571, -6.9571, -6.9582, -6.9572, -6.9576, -6.8518, -6.9577, -6.9975, -6.9975, -6.9977, -6.9977, -6.9978, -6.1787, -4.8167, -6.7401, -6.9251, -6.7078, -6.1794, -5.7342, -5.1882, -5.3099, -6.5209, -6.0064, -6.2678, -6.0726, -5.8376, -5.6603, -5.9925, -5.0943, -5.4661, -5.5763, -5.374, -6.298, -5.8652, -5.733, -5.3584, -4.8361, -5.2978, -5.8012, -5.8301, -5.2147, -5.3556, -5.5191, -5.4072, -5.6783, -5.5563, -4.8657, -5.3387, -5.4216, -5.413, -5.6726, -5.6984, -5.6394, -5.5231, -5.3672, -5.6163, -5.7202, -5.6552, -5.6846, -6.1427, -6.3384, -6.3767, -6.4211, -6.4211, -6.4211, -6.4211, -6.6676, -6.7628, -6.7628, -6.8223, -6.6173, -6.8229, -6.771, -6.824, -6.8256, -6.893, -6.889, -6.7829, -6.8408, -6.9523, -6.9525, -6.9533, -6.9528, -6.9534, -6.9619, -7.0245, -7.0248, -7.0248, -7.0248, -6.136, -6.957, -6.834, -6.5274, -6.3845, -5.7076, -5.8241, -6.3723, -6.4978, -6.7501, -6.0752, -6.3073, -6.1839, -6.3037, -5.9878, -6.2713, -5.9743, -6.355, -5.7414, -5.2347, -6.3297, -5.5556, -6.3339, -5.162, -5.7407, -4.5913, -6.2371, -5.4506, -5.4438, -4.8303, -5.7091, -5.2987, -5.744, -5.3754, -5.4848, -5.7289, -6.1142, -5.7587, -6.0278, -5.8185, -5.7641, -6.0836, -5.767, -5.734, -5.7138, -5.8747, -5.9215, -5.9687, -5.9607, -5.9843, -5.6896, -5.7279, -5.7698, -5.7698, -5.7698, -5.7698, -5.6981, -5.4318, -5.0976, -6.1778, -5.7645, -6.306, -6.3759, -6.3776, -6.3778, -6.3785, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -6.4555, -5.1775, -6.3817, -5.7707, -3.2598, -5.9142, -5.745, -5.2582, -5.6877, -4.4359, -4.7971, -5.6992, -5.7737, -5.733, -5.6188, -5.2279, -5.8891, -5.8681, -5.3625, -5.1974, -5.1727, -5.3739, -5.2203, -5.1027, -5.1842, -5.1049, -5.2647, -5.3979, -5.4551, -5.5809, -5.5755, -5.5951, -5.5866, -5.6899, -5.6102, -5.5886, -5.6543, -5.674, -5.9173, -6.8617, -6.8645, -6.6104, -7.2393, -7.2393, -7.2393, -7.2393, -7.2394, -7.2394, -7.2395, -7.2398, -7.2468, -6.869, -7.2532, -7.2474, -7.2482, -7.298, -6.8641, -7.268, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -7.8545, -6.9025, -6.6022, -5.3918, -7.2878, -7.2468, -7.0918, -7.2797, -7.0588, -7.3012, -7.4279, -7.381, -7.2032, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.7919, -7.792, -7.792, -7.7959, -7.7959, -7.796, -7.7961, -7.7961, -7.7961, -7.7962, -7.7962, -7.7911, -7.7962, -7.7962, -7.7963, -7.7916, -7.7964, -7.7965, -7.7965, -7.7917, -7.4433, -7.17, -7.17, -7.7871, -7.7871, -7.7871, -7.7871, -7.7871, -7.7871, -7.7871, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7872, -7.7873, -7.7873, -7.7873, -7.7873, -7.17, -7.7872, -7.7872, -7.7871, -8.2365, -7.8445, -7.2823, -7.0985, -7.7872, -7.7926, -7.7926, -7.793, -7.7932, -7.7953, -7.8004, -7.7925, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.5555, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6337, -9.6275, -9.6337, -9.6337, -9.6337, -9.6301, -9.6337, -9.6337, -9.6337, -9.6337, -9.6169, -9.6179, -9.6249, -9.6267, -9.6274, -9.6276, -9.6278, -9.6283, -9.6286, -9.6286, -9.6288, -9.6289, -9.629, -9.6291, -9.6294, -9.6294, -9.6294, -9.6295, -9.6297, -9.6299, -9.6299, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6313, -9.6197, -9.6218, -9.6224, -9.6237, -9.6241, -9.6259, -9.6262, -9.6268, -9.6268, -9.6274, -9.6276, -9.6276, -9.6276, -9.6277, -9.6277, -9.6277, -9.6277, -9.6279, -9.6279, -9.628, -9.6283, -9.6283, -9.6284, -9.6285, -9.6285, -9.6286, -9.6286, -9.6286, -9.6287, -9.6287], \"loglift\": [30.0, 29.0, 28.0, 27.0, 26.0, 25.0, 24.0, 23.0, 22.0, 21.0, 20.0, 19.0, 18.0, 17.0, 16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 1.1425, 1.1424, 1.138, 1.1365, 1.132, 1.1305, 1.1303, 1.1302, 1.1285, 1.1281, 1.1281, 1.1279, 1.1257, 1.1253, 1.1246, 1.1246, 1.1229, 1.1226, 1.1209, 1.1206, 1.12, 1.1186, 1.1174, 1.1173, 1.1169, 1.1157, 1.1157, 1.1155, 1.1154, 1.1151, 1.1115, 1.0996, 1.0838, 0.9903, 1.0409, 1.09, 1.0757, 1.0052, 1.0783, 0.888, 0.9782, 0.9086, 0.9965, 0.7511, 0.9344, 0.4678, 0.4979, 0.6894, 0.1256, 0.6717, 0.5279, 0.6165, 0.6891, 0.4442, 0.8401, 0.3178, 0.6865, 0.4125, 0.4748, 0.3763, -0.4271, 0.0295, 0.203, 0.2272, 0.1161, -0.3001, 0.0703, 0.3826, 0.4425, 0.4989, 0.0532, 0.0549, -0.2312, 0.0695, -0.2527, 1.148, 1.1436, 1.1427, 1.1412, 1.1408, 1.1377, 1.137, 1.135, 1.135, 1.1303, 1.1279, 1.1249, 1.1227, 1.1221, 1.1206, 1.1206, 1.1203, 1.1202, 1.12, 1.1198, 1.1193, 1.1191, 1.119, 1.1179, 1.1167, 1.1139, 1.1137, 1.1136, 1.1135, 1.1133, 1.1123, 1.1097, 1.0917, 1.0286, 1.0784, 1.0887, 1.0561, 1.0264, 1.1003, 1.0848, 1.0918, 1.0211, 0.9831, 0.9355, 0.8585, 0.9219, 1.0031, 1.0657, 0.9269, 0.8343, 0.6602, 0.9868, 0.7764, 0.9371, 0.4127, 0.2889, 0.2198, 0.6517, 0.5978, 0.5571, 0.3602, 0.791, 0.5775, 0.4889, 0.4269, 0.4268, 0.6429, 0.3531, 0.5401, 0.3578, 0.4411, 0.4286, 0.6362, 0.2374, 0.4658, 0.3057, 0.3967, 0.072, 0.1827, 0.1477, 0.1033, 0.2187, -0.261, 0.1018, 2.0642, 2.0392, 2.038, 2.0244, 2.0212, 2.0198, 2.0162, 2.0159, 2.0155, 2.0097, 2.0097, 2.0025, 2.0025, 2.0025, 2.0025, 2.0025, 1.9936, 1.9936, 1.9936, 1.9936, 1.9936, 1.9935, 1.9935, 1.9935, 1.9934, 1.9934, 1.9933, 1.9933, 1.9926, 1.9824, 1.9732, 1.8147, 1.9215, 1.8919, 1.9415, 1.9672, 1.7276, 1.7462, 1.9143, 1.7496, 1.6912, 1.6082, 1.928, 1.5093, 1.1552, 1.2819, 1.2688, 1.4423, 0.9368, 1.7469, 1.268, 1.1084, 1.3007, 0.5224, 0.8668, 1.3342, 0.0533, 1.2289, -0.4673, 1.0415, 0.695, 0.1111, 0.7981, -0.8503, -0.2071, 0.1563, -0.052, 0.3097, -0.0687, -0.0016, 0.62, -0.3374, -0.5217, 2.2632, 2.2621, 2.2539, 2.2516, 2.2509, 2.249, 2.2411, 2.2404, 2.2371, 2.2351, 2.2351, 2.2336, 2.2324, 2.2314, 2.2292, 2.2282, 2.2274, 2.2268, 2.225, 2.2249, 2.2249, 2.2249, 2.2249, 2.2249, 2.2213, 2.2209, 2.2185, 2.2168, 2.21, 2.2097, 2.1845, 2.1898, 2.0798, 2.0333, 2.0088, 1.9325, 1.9203, 2.0141, 2.0322, 1.8703, 1.3662, 1.5823, 1.828, 1.2733, 1.5648, 1.275, 1.523, 1.2896, 0.5885, 1.6083, 1.7974, 1.103, 1.1633, 1.3655, 1.3663, 1.3213, 1.2849, 1.3333, 1.2658, 1.5398, 1.4563, 0.9463, 0.738, 0.9889, 1.009, 0.1155, 0.5696, 0.5172, -0.5014, 0.3792, 0.472, 0.4522, 0.9126, 2.5564, 2.5486, 2.5383, 2.5371, 2.5368, 2.5313, 2.5269, 2.5222, 2.5187, 2.5184, 2.5126, 2.4971, 2.4962, 2.4915, 2.4902, 2.488, 2.4875, 2.4874, 2.4874, 2.4873, 2.4873, 2.4868, 2.4864, 2.4858, 2.4849, 2.4833, 2.4833, 2.4832, 2.4832, 2.4832, 2.4608, 2.4121, 2.4724, 2.4802, 2.4621, 2.418, 2.378, 2.301, 2.2929, 2.4059, 2.2976, 2.3438, 2.2939, 2.2199, 2.1381, 2.2276, 1.83, 1.8988, 1.8554, 1.7219, 2.2339, 1.9854, 1.9055, 1.657, 1.2819, 1.519, 1.9033, 1.9041, 1.1577, 1.1707, 1.3834, 1.1697, 1.5402, 1.2724, -0.0691, 0.8014, 0.8106, 0.6962, 1.3479, 1.3374, 1.1099, 0.5314, -0.4736, 0.6844, 1.1935, 0.4557, 0.4118, 2.6682, 2.6674, 2.6649, 2.6621, 2.6621, 2.6621, 2.6621, 2.6349, 2.6346, 2.6345, 2.6289, 2.6288, 2.6286, 2.6285, 2.6263, 2.6233, 2.6218, 2.6193, 2.6182, 2.6155, 2.6153, 2.6153, 2.615, 2.6149, 2.6144, 2.6143, 2.6071, 2.6071, 2.6071, 2.6071, 2.6056, 2.6063, 2.6034, 2.5915, 2.5559, 2.4776, 2.4585, 2.4967, 2.5085, 2.5666, 2.3687, 2.415, 2.3042, 2.3555, 2.1859, 2.3207, 2.1448, 2.3384, 1.9369, 1.5641, 2.2962, 1.7291, 2.281, 1.2104, 1.6581, 0.2052, 2.1612, 1.0757, 1.0569, 0.0633, 1.3582, 0.6824, 1.3745, 0.7049, 0.7355, 1.1939, 1.9662, 1.07, 1.7114, 1.1093, 0.8862, 1.7587, 0.6979, 0.4062, 0.046, 0.7676, 0.3108, 0.3395, 0.1486, 0.5375, 4.3235, 4.3164, 4.3082, 4.3082, 4.3082, 4.3082, 4.3081, 4.2565, 4.2401, 4.1972, 4.19, 4.1663, 4.1555, 4.1537, 4.1482, 4.1421, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1305, 4.1028, 4.1249, 3.8749, 2.8494, 3.8388, 3.7138, 3.4278, 3.5793, 2.5846, 2.7436, 3.487, 3.453, 3.2755, 3.0772, 2.4936, 3.411, 3.3648, 2.4882, 2.0807, 1.9682, 2.1158, 1.529, 1.0019, 1.1882, 0.8628, 1.036, 1.6694, 0.9823, 1.3216, 0.521, 0.8331, 0.5243, 2.5681, 0.5299, -0.6951, -0.8577, 0.444, 5.0925, 4.5081, 4.5061, 4.3855, 4.2212, 4.2212, 4.2212, 4.2212, 4.2211, 4.2211, 4.221, 4.2205, 4.2151, 4.1809, 4.081, 3.8749, 3.8666, 3.8222, 3.8134, 3.7658, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.7059, 3.689, 3.5426, 2.3564, 3.3915, 3.0471, 2.7538, 2.9726, 2.6202, 2.7435, 2.7614, 1.1506, 4.0129, 3.8514, 3.8514, 3.8514, 3.8514, 3.8514, 3.8514, 3.8514, 3.8514, 3.8514, 3.8513, 3.8513, 3.8513, 3.8513, 3.8475, 3.8475, 3.8473, 3.8473, 3.8473, 3.8472, 3.8472, 3.8472, 3.8471, 3.8471, 3.8471, 3.847, 3.847, 3.8469, 3.8469, 3.8468, 3.8372, 2.4734, 4.4587, 4.4586, 3.8624, 3.8624, 3.8624, 3.8624, 3.8624, 3.8624, 3.8624, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8623, 3.8622, 3.8622, 3.8622, 3.8622, 3.5596, 3.463, 3.3729, 3.133, 2.9326, 2.9268, 2.6926, 2.0039, 2.3906, 3.8736, 3.8736, 3.8732, 3.8729, 3.8705, 3.8643, 3.1521, 2.0342, 2.0342, 2.0342, 2.0341, 2.034, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0339, 2.0338, 2.0338, 2.0338, 2.0338, 0.8205, 2.0334, 2.0333, 2.0333, 2.0334, 2.0331, 2.0335, 2.0333, 2.0335, 1.7688, 2.0331, 2.033, 2.0328, 1.7659, 2.0328, 2.0331, 2.0324, 2.033, -4.7234, -4.8214, -4.2671, 0.4932, -3.8677, 1.1617, -3.5098, -3.3961, -3.1068, -3.7246, -3.5242, -3.5324, -3.3283, -3.6964, -3.1481, -3.6617, -3.8196, 0.803, -3.3215, -3.519, -3.3383, 2.0367, 2.0367, 2.0366, 2.0366, 2.0365, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0363, 2.0362, 2.0362, 2.0362, 2.0361, 2.0361, 2.0361, 2.0361, 2.036, 2.0361, 2.036, 2.036, 2.035, 2.0349, 2.0349, 2.035, 2.0348, 2.0348, 2.0349, 2.035, 2.0347, 2.0348, 2.0349, 2.0349, 2.0349, 2.035, 2.0349, 2.035, 2.0349, 2.0349, 2.0349, 2.0348, 2.0348, 2.0349, 2.035, 2.0349, 2.0349, 2.0349, 2.0349, 2.035, 2.035, -4.7261, -4.8252, -4.2646, -3.8139, -3.393, -3.7218, -3.5216, -3.867, -3.6264, -3.5627, -3.6598, -3.5474, -3.5167, -3.695, -2.9666, -3.4117, -3.5313, -3.3956, -3.3599, -3.3273, -3.3252, -3.5739, -3.6473, -3.3125, -3.5105, -3.4884, -3.2432, -2.8299, -3.5194, -2.5995]}, \"token.table\": {\"Topic\": [4, 2, 5, 4, 2, 2, 5, 7, 2, 3, 1, 3, 6, 1, 3, 6, 1, 3, 1, 2, 3, 4, 5, 1, 2, 3, 5, 6, 1, 3, 4, 5, 4, 1, 2, 3, 4, 5, 6, 7, 6, 2, 2, 3, 4, 5, 4, 5, 7, 3, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 7, 5, 3, 1, 2, 3, 4, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 7, 7, 6, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 5, 1, 2, 4, 5, 3, 2, 5, 7, 4, 4, 3, 6, 1, 1, 2, 3, 6, 7, 5, 7, 2, 1, 2, 4, 6, 1, 2, 3, 2, 3, 1, 2, 3, 5, 6, 1, 3, 5, 6, 4, 2, 5, 7, 2, 6, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 4, 6, 1, 2, 3, 4, 5, 7, 1, 2, 3, 6, 5, 2, 5, 6, 3, 1, 1, 3, 5, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 6, 3, 5, 4, 2, 5, 7, 7, 2, 4, 5, 1, 2, 3, 4, 6, 7, 1, 2, 3, 2, 6, 7, 6, 1, 2, 3, 6, 2, 4, 5, 1, 2, 3, 4, 5, 6, 1, 1, 2, 3, 4, 5, 7, 2, 4, 7, 5, 7, 5, 1, 2, 4, 5, 6, 1, 1, 2, 3, 7, 5, 1, 2, 3, 4, 5, 6, 7, 1, 2, 6, 2, 1, 2, 4, 5, 6, 7, 1, 2, 3, 5, 2, 3, 2, 3, 4, 2, 3, 5, 2, 3, 4, 5, 6, 7, 4, 5, 6, 3, 1, 2, 1, 2, 1, 2, 3, 4, 5, 1, 2, 4, 5, 1, 2, 3, 5, 3, 2, 4, 6, 2, 4, 5, 6, 3, 3, 1, 2, 3, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 6, 5, 3, 2, 3, 4, 5, 6, 1, 2, 3, 4, 6, 2, 5, 7, 3, 4, 1, 2, 3, 6, 1, 6, 1, 1, 4, 5, 6, 1, 2, 3, 7, 6, 2, 6, 1, 2, 3, 4, 5, 6, 7, 4, 1, 2, 3, 5, 6, 1, 2, 3, 4, 5, 6, 7, 1, 4, 5, 6, 6, 1, 2, 3, 4, 5, 6, 7, 2, 5, 7, 2, 1, 2, 3, 5, 6, 7, 4, 4, 5, 1, 2, 3, 4, 5, 1, 4, 2, 3, 5, 7, 2, 5, 6, 7, 2, 3, 5, 7, 5, 7, 1, 2, 3, 4, 5, 6, 6, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 3, 1, 2, 3, 4, 5, 6, 7, 5, 3, 5, 5, 5, 1, 4, 5, 6, 5, 5, 2, 3, 4, 5, 2, 3, 1, 2, 3, 4, 5, 6, 1, 2, 3, 5, 6, 7, 2, 6, 4, 5, 7, 2, 1, 2, 4, 5, 7, 2, 3, 4, 5, 6, 1, 2, 4, 5, 6, 1, 2, 3, 4, 5, 7, 2, 3, 5, 1, 2, 2, 4, 5, 6, 7, 3, 5, 2, 3, 6, 1, 2, 3, 4, 4, 4, 6, 6, 1, 7, 1, 2, 3, 4, 5, 6, 2, 1, 2, 3, 6, 7, 1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 7, 2, 3, 4, 5, 6, 2, 4, 1, 2, 3, 4, 5, 6, 7, 2, 7, 7, 2, 6, 5, 6, 7, 5, 7, 1, 2, 3, 2, 7, 2, 4, 5, 6, 7, 4, 5, 5, 6, 5, 7, 2, 3, 7, 1, 2, 3, 5, 7, 4, 2, 4, 5, 6, 8, 2, 5, 1, 4, 1, 7, 3, 1, 3, 7, 2, 3, 1, 2, 3, 4, 5, 6, 7, 6, 1, 6, 1, 3, 5, 7, 1, 6, 1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 1, 2, 3, 4, 5, 4, 2, 3, 1, 2, 3, 4, 5, 6, 7, 3, 1, 2, 3, 4, 5, 6, 7, 6, 1, 2, 3, 2, 3, 4, 6, 1, 2, 3, 4, 5, 6, 7, 4, 1, 2, 3, 4, 5, 6, 7, 4, 2, 3, 4, 5, 6, 5, 7, 1, 1, 1, 3, 4, 2, 3, 7, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 5, 6, 5, 4, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 6, 2, 6, 1, 2, 3, 4, 5, 6, 7, 6, 3, 1, 6, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 7, 2, 6, 2, 6, 3, 1, 2, 3, 5, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 4, 5, 1, 2, 3, 4, 5, 6, 4, 7, 2, 3, 7, 5, 6, 4, 7, 5, 4, 1, 2, 3, 6, 2, 4, 2, 4, 5, 5, 2, 5, 6, 1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 7, 1, 2, 3, 2, 2, 3, 6, 1, 3, 5, 3, 2, 5, 6, 6, 2, 6, 3, 6, 1, 2, 3, 5, 6, 2, 3, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 6, 1, 2, 3, 4, 5, 6, 7, 7, 2, 1, 1, 1, 3, 1, 2, 3, 5, 1, 2, 3, 4, 5, 6, 7, 7, 6, 1, 2, 3, 6, 3, 6, 5, 2, 4, 1, 2, 3, 4, 5, 6, 6, 1, 2, 3, 6, 1, 3, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 7, 2, 4, 5, 2, 3, 6, 1, 2, 3, 1, 1, 6, 1, 6, 2, 1, 2, 3, 4, 6, 7, 3, 4, 6, 5, 5, 1, 2, 3, 4, 5, 3, 1, 2, 3, 4, 5, 6, 8, 6, 1, 2, 3, 4, 5, 6, 7, 3, 3, 1, 2, 3, 5, 1, 2, 3, 4, 5, 6, 5, 5, 3, 1, 2, 3, 5, 3, 6, 2, 1, 4, 4, 3, 4, 4, 5, 6, 4, 5, 1, 2, 3, 4, 5, 6, 5, 6, 7, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 1, 2, 2, 3, 4, 5, 6, 7, 1, 6, 3, 1, 3, 1, 7, 1, 2, 3, 4, 6, 1, 3, 2, 4, 1, 2, 3, 5, 7, 3, 1, 3, 1, 2, 3, 4, 5, 6, 4, 1, 2, 3, 5, 2, 6, 3, 2, 3, 3, 1, 2, 3, 5, 6, 7, 1, 2, 3, 5, 5, 1, 2, 3, 1, 2, 3, 4, 5, 6, 2, 2, 6, 1, 2, 3, 4, 5, 6, 4, 5, 6, 1, 2, 6, 1, 1, 2, 3, 4, 6, 1, 4, 1, 2, 4, 1, 3, 1, 3, 3, 3, 2, 2, 7, 2, 7, 6], \"Freq\": [0.8921307994873069, 0.988814693807791, 0.9247685978965509, 0.9140963479377016, 0.9661552822174307, 0.9737990747884806, 0.9251517641602246, 0.9144043036527834, 0.9682687740168265, 0.9497538277348139, 0.9358707083052668, 0.032271403734664375, 0.032271403734664375, 0.7417633875277159, 0.8444687165011691, 0.16889374330023382, 0.9260944449998534, 0.054476143823520784, 0.9283783815768158, 0.1288511655485096, 0.0322127913871274, 0.644255827742548, 0.161063956935637, 0.763541751863008, 0.08810097136880862, 0.10278446659694339, 0.01468349522813477, 0.05873398091253908, 0.1549705655192655, 0.1549705655192655, 0.619882262077062, 0.06198822620770619, 0.9155941637027961, 0.21519011132605634, 0.34617539648104717, 0.05613655078071035, 0.14969746874856094, 0.07484873437428047, 0.14034137695177587, 0.009356091796785058, 0.9305691581752048, 0.9656550374307071, 0.5922494844923706, 0.06909577319077656, 0.24677061853848772, 0.08883742267385558, 0.2719582788845634, 0.6798956972114085, 0.48288756572972075, 0.9794811273169214, 0.8112547020452198, 0.14067808499688095, 0.5024217321317177, 0.14737704142530383, 0.060290607855806116, 0.040193738570537416, 0.09378538999792063, 0.020096869285268708, 0.32953382157866284, 0.47076260225523264, 0.033625900161088046, 0.1479539607087874, 0.020175540096652827, 0.9308769176055488, 0.9149415704550155, 0.31896479688400764, 0.09967649902625239, 0.15948239844200382, 0.07974119922100191, 0.33890009668925813, 0.48288756572972075, 0.619192904636424, 0.30271653115558506, 0.06879921162626933, 0.036410357287642754, 0.5340185735520937, 0.012136785762547585, 0.07282071457528551, 0.30341964406368965, 0.036410357287642754, 0.8427158884894469, 0.5574318411243866, 0.8826202758291282, 0.12161210647592162, 0.12161210647592162, 0.6323829536747924, 0.12161210647592162, 0.049766622298830214, 0.3234830449423964, 0.17418317804590575, 0.2073609262451259, 0.1161221186972705, 0.10782768164746546, 0.01658887409961007, 0.01639536899710844, 0.4700005779171086, 0.21313979696240973, 0.12023270597879522, 0.0819768449855422, 0.0710465989874699, 0.027325614995180735, 0.08241734132376, 0.35027370062598, 0.47389971261162, 0.08241734132376, 0.943383731845735, 0.25653205081151387, 0.48741089654187636, 0.18812350392844351, 0.05130641016230277, 0.9546580479458803, 0.09858417632332231, 0.7393813224249173, 0.14787626448498348, 0.8986938649279598, 0.942016695955424, 0.2812499469975985, 0.7031248674939962, 0.9418285438187413, 0.4804208968974142, 0.02826005275867142, 0.3956407386213999, 0.09891018465534998, 0.8168363541678048, 0.13858370821216093, 0.6929185410608045, 0.9898750344259051, 0.2758979314833173, 0.03941399021190247, 0.19706995105951236, 0.4729678825428297, 0.10934387862748246, 0.8747510290198597, 0.872918006929054, 0.9649688891223609, 0.05078783626959794, 0.37445132600181724, 0.04992684346690896, 0.44934159120218065, 0.09985368693381792, 0.02496342173345448, 0.46135927667316806, 0.44130017768737817, 0.06017729695736975, 0.020059098985789916, 0.9206548491275556, 0.12912467987545256, 0.3873740396263577, 0.3873740396263577, 0.34005289960691, 0.68010579921382, 0.12075131459180687, 0.439534785114177, 0.06762073617141184, 0.14490157751016824, 0.09177099908977321, 0.1304114197591514, 0.004830052583672274, 0.2254831094920161, 0.36847239843817264, 0.05499588036390637, 0.2089843453828442, 0.11549134876420336, 0.010999176072781273, 0.01649876410917191, 0.29101814032614115, 0.6547908157338176, 0.061347494069643405, 0.5258356634540863, 0.043819638621173856, 0.11393106041505204, 0.23662604855433883, 0.008763927724234772, 0.17292196150812716, 0.5805237279201413, 0.16057039282897523, 0.08646098075406358, 0.8931243082061336, 0.21633435918776173, 0.17306748735020938, 0.5624693338881805, 0.9412191833401389, 0.9449590201829416, 0.9388005827234657, 0.04694002913617328, 0.9593885271005725, 0.3340220242392063, 0.3785582941377671, 0.05938169319808111, 0.11876338639616223, 0.08907253979712168, 0.007422711649760139, 0.014845423299520278, 0.13038844860015134, 0.08692563240010089, 0.12417947485728698, 0.391165345800454, 0.1676422910573374, 0.08692563240010089, 0.006208973742864349, 0.037158118491943726, 0.1486324739677749, 0.2477207899462915, 0.35919514542212266, 0.21056267145434776, 0.8736220244530797, 0.9751508655550499, 0.9721467516430485, 0.9659635100672791, 0.896229624990085, 0.0689407403838527, 0.48288756572972075, 0.0406883320769849, 0.12206499623095471, 0.813766641539698, 0.33082463489305447, 0.47935814443687486, 0.020254569483248233, 0.10802437057732392, 0.0607637084497447, 0.48288756572972075, 0.47075441598722734, 0.416733417431316, 0.10804199711182266, 0.09949680340938856, 0.7959744272751085, 0.48288756572972075, 0.8271067938539561, 0.13556567879384782, 0.5573255683747077, 0.04518855959794927, 0.2560685043883792, 0.17353170984299765, 0.809814645933989, 0.9247076541672868, 0.5142672028916744, 0.3309197653389905, 0.0715502195327547, 0.017887554883188675, 0.03130322104558018, 0.03130322104558018, 0.8283427185418673, 0.2162676023070617, 0.4557067334327372, 0.11585764409306878, 0.07723842939537919, 0.10813380115353086, 0.023171528818613757, 0.9663704904813804, 0.914807958785936, 0.871634063474492, 0.959630248920698, 0.9094669907588537, 0.9251393821923332, 0.146181021257109, 0.5603605814855844, 0.04060583923808583, 0.06496934278093733, 0.18678686049519483, 0.7828208690263558, 0.26409100524884604, 0.26409100524884604, 0.46949512044239294, 0.48288756572972075, 0.8202276852132369, 0.14135387746066194, 0.15902311214324466, 0.035338469365165485, 0.26503852023874114, 0.2473692855561584, 0.0883461734129137, 0.0883461734129137, 0.9488013844121033, 0.1734496339438041, 0.7805233527471185, 0.9682565693497363, 0.03329518382855887, 0.1664759191427944, 0.3329518382855888, 0.3495994301998682, 0.0832379595713972, 0.03329518382855887, 0.35232668753924656, 0.11010208985601455, 0.4404083594240582, 0.06606125391360873, 0.9081426853119822, 0.056758917831998885, 0.9570010177105387, 0.6059805128862391, 0.30299025644311955, 0.31061680127883545, 0.31061680127883545, 0.31061680127883545, 0.018048499968459128, 0.10829099981075478, 0.4331639992430191, 0.3068244994638052, 0.10829099981075478, 0.036096999936918256, 0.3081993864082914, 0.6934486194186558, 0.8721684600873549, 0.9977874921595214, 0.10952675364090762, 0.7666872754863534, 0.05641999821512304, 0.9591399696570917, 0.04636133769275297, 0.5795167211594121, 0.05795167211594121, 0.19703568519420012, 0.11590334423188242, 0.9483725225984295, 0.3582431238054732, 0.6187835774821809, 0.03256755670958847, 0.31032311613395935, 0.35629691111676814, 0.2988296673882571, 0.04597379498280879, 0.9467227898251473, 0.22679024168694917, 0.05669756042173729, 0.6803707250608475, 0.025336373113721895, 0.17735461179605325, 0.5067274622744379, 0.2787001042509408, 0.6917573569936253, 0.9590084805423155, 0.3746095852867922, 0.3433921198462262, 0.28095718896509414, 0.3446196899041984, 0.1723098449520992, 0.3759487526227619, 0.04699359407784524, 0.04699359407784524, 0.38485496429029215, 0.3420933015913708, 0.0855233253978427, 0.10384975226880899, 0.0855233253978427, 0.22469138964651822, 0.7489712988217274, 0.9595673151908108, 0.8728640164669911, 0.9714002413710814, 0.5848893880376593, 0.19496312934588644, 0.19298066171847963, 0.7719226468739185, 0.33600729765430243, 0.3573410943307661, 0.11733588172055007, 0.058667940860275034, 0.13333622922789778, 0.40039580139318387, 0.26693053426212254, 0.26693053426212254, 0.8739672680396499, 0.9551120942666133, 0.7319341520093865, 0.20585648025263995, 0.06861882675087998, 0.022872942250293328, 0.9394866827544682, 0.052193704597470456, 0.9478969074954158, 0.27925952205970733, 0.4887041636044878, 0.1256667849268683, 0.09774083272089756, 0.48034384595312624, 0.37117479005468845, 0.06550143353906267, 0.08733524471875022, 0.8908066847571261, 0.3247607647904673, 0.3247607647904673, 0.3523492343718176, 0.26561711514183173, 0.06504908942248941, 0.1626227235562235, 0.11383590648935646, 0.027103787259370585, 0.016262272355622352, 0.955259712801646, 0.5050564868805458, 0.3690797404127066, 0.038850498990811215, 0.038850498990811215, 0.058275748486216826, 0.15855976194368754, 0.4700164371902166, 0.02265139456338393, 0.06229133504930581, 0.16422261058453352, 0.09626842689438171, 0.01698854592253795, 0.9916864189873765, 0.3023732726343971, 0.32015993573053814, 0.3735199250189612, 0.8859053752167033, 0.2442843614718962, 0.34303761398181165, 0.06756801487520533, 0.17671634659669086, 0.12474095053884061, 0.03638277724049518, 0.010395079211570051, 0.7862547463615083, 0.26171419972634713, 0.6542854993158679, 0.9668141848449979, 0.3282336633454217, 0.1750579537842249, 0.12035234322665463, 0.05470561055757028, 0.3063514191223936, 0.48288756572972075, 0.9221325927244919, 0.15138451015345203, 0.8410250564080669, 0.2665770597521367, 0.239919353776923, 0.079973117925641, 0.3598790306653845, 0.053315411950427334, 0.9916254355270976, 0.914807958785936, 0.11058416448546113, 0.8293812336409585, 0.8045254565104923, 0.20113136412762309, 0.07222594554114085, 0.21667783662342258, 0.3611297277057043, 0.3611297277057043, 0.4991806457301623, 0.12479516143254057, 0.12479516143254057, 0.37438548429762175, 0.4198521569839722, 0.4198521569839722, 0.19389140102866217, 0.4247144974913552, 0.04616461929253861, 0.2492889441797085, 0.07386339086806178, 0.009232923858507722, 0.8218488105861483, 0.9761080854443458, 0.08714062773353308, 0.49794644419161765, 0.09958928883832353, 0.07469196662874264, 0.03734598331437132, 0.19917857767664707, 0.6123187769905625, 0.28260866630333653, 0.10597824986375119, 0.6910980005470181, 0.38670632385060544, 0.2640921236052915, 0.02829558467199552, 0.05659116934399104, 0.0943186155733184, 0.16034164647464128, 0.01886372311466368, 0.7556426876927475, 0.9149743881450032, 0.9233633943004652, 0.9260728853945126, 0.9648299598869388, 0.985752359818327, 0.13219801545828944, 0.8592871004788813, 0.8825680101894879, 0.855933153614974, 0.8986305227205323, 0.12224018358491107, 0.09779214686792885, 0.024448036716982213, 0.7334411015094664, 0.9360171636931125, 0.05200095353850625, 0.3887455572952612, 0.3821566495444941, 0.03953344650460283, 0.05271126200613711, 0.07906689300920566, 0.059300169756904254, 0.34465229173088024, 0.20679137503852815, 0.09190727779490139, 0.11488409724362675, 0.06893045834617605, 0.16083773614107744, 0.9411836949057212, 0.04705918474528606, 0.31324062455587737, 0.5325090617449916, 0.12529624982235094, 0.9794734063309015, 0.20811044486386113, 0.05946012710396032, 0.05946012710396032, 0.6243313345915834, 0.02973006355198016, 0.9573966739992821, 0.03718568480622638, 0.8924564353494332, 0.03718568480622638, 0.9361101521063877, 0.05576339237245831, 0.3066986580485207, 0.08364508855868746, 0.5018705313521248, 0.08364508855868746, 0.2210586370208536, 0.3735128694490285, 0.07622711621408744, 0.2591721951278973, 0.04573626972845247, 0.03049084648563498, 0.7890045051180105, 0.11688955631377933, 0.08766716723533449, 0.13683566144651485, 0.8483811009683921, 0.13587065960671993, 0.38043784689881577, 0.39402491285948776, 0.06793532980335996, 0.013587065960671992, 0.8723498878980713, 0.9742947010422852, 0.8857353490648707, 0.06326681064749076, 0.9001186630786617, 0.6238129605167374, 0.16478078202328914, 0.15301072616448277, 0.05885027929403183, 0.9482887443072714, 0.9362649367273874, 0.08511499424794432, 0.9365278019567821, 0.9919576378700847, 0.48288756572972075, 0.2576680265205777, 0.41717680484284003, 0.04907962409915765, 0.03680971807436824, 0.10429420121071001, 0.13496896627268354, 0.9585324170411983, 0.031242239374768846, 0.8435404631187589, 0.031242239374768846, 0.031242239374768846, 0.031242239374768846, 0.1098074207805681, 0.18118224428793736, 0.13725927597571014, 0.15922076013182374, 0.14824001805376694, 0.07686519454639767, 0.18667261532696577, 0.0682849425775061, 0.10925590812400977, 0.3960526669495354, 0.28679675882552563, 0.1365698851550122, 0.020166046585961665, 0.020166046585961665, 0.5041511646490416, 0.36298883854730996, 0.08066418634384666, 0.9671644761215998, 0.9515172562600646, 0.3214972644596673, 0.43951524761574773, 0.10173964065179346, 0.07732212689536302, 0.028487099382502167, 0.03255668500857391, 0.48288756572972075, 0.7294798482574448, 0.21884395447723345, 0.48288756572972075, 0.9046494600354624, 0.9275696136009738, 0.9696199825533288, 0.9298901088580087, 0.871634063474492, 0.19677859357023608, 0.7871143742809443, 0.38514984691166854, 0.5463753642235297, 0.06269881228794603, 0.9900511573221282, 0.48288756572972075, 0.10825721731878706, 0.16238582597818058, 0.5142217822642385, 0.16238582597818058, 0.027064304329696764, 0.8895508135734014, 0.9116964343028532, 0.9474892247592738, 0.88451342572576, 0.9594972550974413, 0.8619934714332572, 0.9317103971800065, 0.0716700305523082, 0.48288756572972075, 0.4233361764287666, 0.1893872368233956, 0.022280851390987715, 0.3453531965603096, 0.022280851390987715, 0.9147524175876084, 0.0282738977979677, 0.7351213427471602, 0.0282738977979677, 0.1413694889898385, 0.0282738977979677, 0.09188281048233041, 0.8269452943409736, 0.9487859628634349, 0.8910770704358996, 0.917248978984809, 0.48288756572972075, 0.8736228259512168, 0.2767296551105206, 0.6918241377763015, 0.48288756572972075, 0.9659986341687781, 0.8723342502463054, 0.22908691263195252, 0.2603260370817642, 0.15619562224905853, 0.020826082966541138, 0.22908691263195252, 0.06247824889962341, 0.05206520741635284, 0.8851380104894508, 0.9686061027182726, 0.931437639753867, 0.9918666798230028, 0.18855472145343435, 0.18855472145343435, 0.5656641643603031, 0.9650075661489288, 0.8721491171081256, 0.23048933554879045, 0.46615820672789077, 0.1320781585729024, 0.11136001605166279, 0.03625674941216928, 0.02330791033639454, 0.051923479909716096, 0.10384695981943219, 0.7269287187360253, 0.10384695981943219, 0.028191095579057104, 0.4698515929842851, 0.13155844603559982, 0.27251392393088536, 0.09397031859685702, 0.8799850986892495, 0.9139138987063996, 0.050772994372577755, 0.4993523680768603, 0.23612786397432928, 0.07354802320511895, 0.07354802320511895, 0.042580434487174135, 0.06967707461537585, 0.0077418971794862065, 0.591782716485153, 0.2358042906513449, 0.2751050057599024, 0.03930071510855748, 0.3799069127160557, 0.05240095347807665, 0.013100238369519162, 0.013100238369519162, 0.9669738182487259, 0.818486277299125, 0.054565751819941666, 0.10913150363988333, 0.3384354748326236, 0.15511625929828582, 0.3948413873047275, 0.09871034682618188, 0.14728178587565383, 0.27001660743869865, 0.07364089293782691, 0.1718287501882628, 0.2454696431260897, 0.06136741078152243, 0.012273482156304485, 0.9599569395684988, 0.6616707618766013, 0.1940900901504697, 0.00882227682502135, 0.044111384125106755, 0.0176445536500427, 0.05293366095012811, 0.0176445536500427, 0.8924516643139895, 0.21745590659333025, 0.06213025902666578, 0.21745590659333025, 0.12426051805333156, 0.3727815541599947, 0.4692345369850729, 0.4692345369850729, 0.9248279572114811, 0.9212024842910953, 0.25623837046179754, 0.7260087163084264, 0.9354968590497711, 0.5982330766191843, 0.09970551276986406, 0.2991165383095922, 0.534960109440234, 0.3497816100186145, 0.041150777649248765, 0.06172616647387315, 0.1431252251329894, 0.6679177172872839, 0.17890653141623675, 0.011927102094415783, 0.33625930160641704, 0.11208643386880568, 0.05604321693440284, 0.11208643386880568, 0.36428091007361846, 0.8847423993989749, 0.8651692080227604, 0.35326842948377657, 0.4102472084327728, 0.053722848723339295, 0.06023470917465315, 0.04721098827202544, 0.07000249985162393, 0.004883895338485391, 0.10835445634179448, 0.43341782536717793, 0.03333983272055215, 0.2667186617644172, 0.10001949816165645, 0.050009749080828225, 0.008334958180138038, 0.8725805266180696, 0.9127507773598702, 0.06085005182399134, 0.1928220123151421, 0.3590478850006094, 0.03324517453709346, 0.15292780287062993, 0.14627876796321124, 0.07978841888902431, 0.03324517453709346, 0.9297029108140275, 0.9762243389026346, 0.9349763033201087, 0.9669738182487259, 0.05781449711811827, 0.23125798847247309, 0.03854299807874551, 0.17344349135435483, 0.5010589750236917, 0.02480848398953142, 0.06202120997382856, 0.06202120997382856, 0.35972301784820565, 0.47136119580109703, 0.01240424199476571, 0.13569185512504173, 0.8141511307502504, 0.09314690628005447, 0.8383221565204901, 0.9334017736974635, 0.46799832696875415, 0.27529313351103185, 0.05505862670220637, 0.08258794005330955, 0.13764656675551593, 0.17857415912565838, 0.02142889909507901, 0.30000458733110613, 0.23571789004586907, 0.2214319573158164, 0.03571483182513168, 0.13574435585254913, 0.6787217792627457, 0.16289322702305897, 0.24763080613764463, 0.6809847168785228, 0.2260737248478367, 0.14386509763044153, 0.06165647041304637, 0.4726996065000222, 0.08220862721739516, 0.02055215680434879, 0.9145380525211538, 0.7704061631355873, 0.8472212650694186, 0.09775629981570215, 0.032585433271900714, 0.8919301791957162, 0.9298843827478025, 0.6201553619412777, 0.3720932171647667, 0.8896202707703004, 0.9702359647884319, 0.17458980718260236, 0.05819660239420078, 0.7274575299275098, 0.02909830119710039, 0.3028411960281209, 0.6729804356180464, 0.9846762652138451, 0.7539943974964943, 0.21991503260314416, 0.9241480040216764, 0.04377156430286484, 0.13131469290859454, 0.7878881574515673, 0.20617382628590872, 0.17672042253077888, 0.08836021126538944, 0.10308691314295436, 0.41234765257181744, 0.5300995308489516, 0.9615852460765726, 0.6250802203375566, 0.17859434866787333, 0.17859434866787333, 0.014882862388989443, 0.023837981592676912, 0.7866533925583381, 0.1907038527414153, 0.9438779775713874, 0.1345442827644117, 0.20181642414661755, 0.6054492724398526, 0.25375960613227194, 0.5392391630310779, 0.22203965536573797, 0.9047596884779163, 0.21666846711460597, 0.16250135033595448, 0.5416711677865149, 0.8795460163551974, 0.0763454349948853, 0.9161452199386236, 0.8771132737625902, 0.10963915922032377, 0.1222554350300601, 0.7063647357292362, 0.10867149780449786, 0.05433574890224893, 0.013583937225562233, 0.16389070292756097, 0.2048633786594512, 0.04097267573189024, 0.5736174602464634, 0.4868459555835881, 0.28128877433718424, 0.05409399506484312, 0.07573159309078037, 0.032456397038905876, 0.07573159309078037, 0.45761321013839945, 0.21927299652464974, 0.3146090819701496, 0.009533608544549987, 0.24171035726272247, 0.5362948551766654, 0.03021379465784031, 0.015106897328920154, 0.14351552462474146, 0.007553448664460077, 0.02266034599338023, 0.871634063474492, 0.9489341246369868, 0.96049855675712, 0.9140602937470835, 0.4155619976704364, 0.562230938024708, 0.32657117333640506, 0.15072515692449465, 0.4270546112860682, 0.1004834379496631, 0.11631285881072506, 0.12739027393555602, 0.07200319831140123, 0.36001599155700614, 0.2713966705583585, 0.038770952936908354, 0.016616122687246437, 0.871634063474492, 0.9669738182487259, 0.2684805071013837, 0.14456642690074506, 0.45435162740234164, 0.14456642690074506, 0.8723383146774595, 0.9316788238876654, 0.9593885271005725, 0.9359420009894389, 0.8707064145515001, 0.07891424960793486, 0.2254692845940996, 0.07891424960793486, 0.16910196344557468, 0.2705631415129195, 0.19164889190498466, 0.929266012916131, 0.13776020342343806, 0.11020816273875045, 0.7025770374595341, 0.04132806102703142, 0.08565349913227478, 0.8565349913227478, 0.9149426108260686, 0.030809279944757968, 0.4159252792542326, 0.10783247980665289, 0.2002603196409268, 0.09242783983427391, 0.07702319986189493, 0.07702319986189493, 0.1802062871946696, 0.21938156701959777, 0.10185572754481326, 0.3604125743893392, 0.01567011192997127, 0.1331959514047558, 0.42893505266557125, 0.39080749242863155, 0.047659450296174584, 0.04289350526655712, 0.061957285385026956, 0.023829725148087292, 0.15742725943015454, 0.052475753143384846, 0.7346605440073878, 0.7782975938419542, 0.09530174618472909, 0.1111853705488506, 0.08204050211003294, 0.8614252721553458, 0.04102025105501647, 0.9865928331263218, 0.9741612064001158, 0.8720239039018942, 0.9512177777536827, 0.03963407407307011, 0.5291168530582077, 0.07732495620480251, 0.730291253045357, 0.07732495620480251, 0.04295830900266806, 0.07732495620480251, 0.4460075400279609, 0.6767202009782328, 0.12889908590061577, 0.16112385737576973, 0.9239954075607005, 0.9141194651266565, 0.05552708032137399, 0.31928071184790047, 0.13881770080343497, 0.48586195281202244, 0.013881770080343497, 0.873813906495324, 0.24681664990601512, 0.4411191189809632, 0.12078261591145421, 0.16804537865941455, 0.021005672332426818, 0.0052514180831067046, 0.737744882243962, 0.8720966250220237, 0.14310875204211831, 0.22897400326738931, 0.12879787683790647, 0.07155437602105916, 0.11448700163369466, 0.25759575367581294, 0.05724350081684733, 0.8737335658296709, 0.8737567043449973, 0.8024492094282211, 0.026748306980940703, 0.053496613961881406, 0.10699322792376281, 0.058323111127820154, 0.16663746036520044, 0.024995619054780066, 0.31661117469388084, 0.24162431752954064, 0.1916330794199805, 0.8550248782204185, 0.9121848000133452, 0.9343329823184485, 0.8420517158275245, 0.09848558079854088, 0.04431851135934339, 0.014772837119781132, 0.9497674666723152, 0.9669738182487259, 0.5811923199820009, 0.9414701784812839, 0.914807958785936, 0.8860353891931989, 0.9149580350021107, 0.9738434453258966, 0.10546003454017376, 0.42184013816069504, 0.4482051467957385, 0.7831541688065762, 0.22375833394473607, 0.31905785683700355, 0.31905785683700355, 0.22972165692264257, 0.012762314273480143, 0.089336199914361, 0.012762314273480143, 0.8313711963076214, 0.8949323518701849, 0.9144559034724536, 0.14812772323847995, 0.6850907199779698, 0.16664368864328993, 0.032307398875263994, 0.7753775730063358, 0.19384439325158395, 0.20388846769965108, 0.3826602401029683, 0.07830499121798193, 0.18024922506780747, 0.06944027523104059, 0.07978244388247216, 0.004432357993470675, 0.8785464832732406, 0.05856976555154937, 0.05856976555154937, 0.9242320407006887, 0.9333696930032823, 0.9752605910116443, 0.06933905650894351, 0.06933905650894351, 0.45763777295902713, 0.2912240373375627, 0.08320686781073221, 0.0277356226035774, 0.29627244250076595, 0.651799373501685, 0.9136636522994126, 0.09148154966212023, 0.823333946959082, 0.9867897527366404, 0.9046491475969631, 0.5169158714909473, 0.25244728607697425, 0.07212779602199264, 0.07212779602199264, 0.08414909535899141, 0.9147910920653938, 0.8725432275425268, 0.964568128961408, 0.9210370293878652, 0.3766180587978826, 0.3766180587978826, 0.04707725734973533, 0.04707725734973533, 0.14123177204920598, 0.9149694143357624, 0.860208042585851, 0.13763328681373616, 0.17947644373831015, 0.5936528523651797, 0.08743724182122803, 0.11504900239635266, 0.013805880287562319, 0.004601960095854106, 0.921493416596603, 0.07180337827782492, 0.8137716204820157, 0.023934459425941638, 0.07180337827782492, 0.8430262815182586, 0.9186253389066309, 0.48550785291373516, 0.9080339277156974, 0.06485956626540695, 0.6420627130785563, 0.4539820002833986, 0.3902652283137988, 0.11150435094679965, 0.01592919299239995, 0.007964596496199974, 0.01592919299239995, 0.5804279831981789, 0.2849373735700151, 0.10553236058148707, 0.031659708174446126, 0.8860427534182493, 0.8555396704774447, 0.11882495423297842, 0.023764990846595686, 0.5282615196385032, 0.28945836692520727, 0.014472918346260364, 0.04341875503878109, 0.07236459173130182, 0.04341875503878109, 0.923195128404519, 0.32869747385192155, 0.6573949477038431, 0.4890338980177195, 0.3217328276432365, 0.03860793931718838, 0.04504259587005312, 0.04504259587005312, 0.0643465655286473, 0.24006216278048148, 0.7420103213214883, 0.8682480479609288, 0.14459087488075903, 0.8313975305643645, 0.03614771872018976, 0.9756511149132023, 0.11163044135608009, 0.04961352949159115, 0.7690097071196629, 0.03100845593224447, 0.03721014711869337, 0.9231491092205203, 0.04858679522213265, 0.9549097295095449, 0.7211276815015214, 0.95554703423395, 0.7783704510907062, 0.20883109663409194, 0.934191049808183, 0.9826735075640929, 0.6743993316517168, 0.8723370005962289, 0.9733618109242528, 0.5954572656990088, 0.3572743594194053, 0.9714108705048039, 0.782094353887611, 0.9298885254350214], \"Term\": [\"abanderung\", \"ablegen\", \"abliefern\", \"abonnement\", \"adalbert_stifter\", \"akademisch\", \"amstadter\", \"amtieren\", \"amtszeit\", \"anfugen\", \"angabe\", \"angabe\", \"angabe\", \"angezeigt\", \"anhang\", \"anhang\", \"anlage\", \"anlage\", \"anmeldegebuhr\", \"anmelden\", \"anmelden\", \"anmelden\", \"anmelden\", \"anmeldung\", \"anmeldung\", \"anmeldung\", \"anmeldung\", \"anmeldung\", \"anmeldungen\", \"anmeldungen\", \"anmeldungen\", \"anmeldungen\", \"annemarie\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"anschlie\\u00dfen\", \"ansprache\", \"antiquare\", \"antrag\", \"antrag\", \"antrag\", \"antrag\", \"antragsliste\", \"antragsliste\", \"antwortrede\", \"anzufuhren\", \"anzugehoren\", \"arbeit\", \"arbeit\", \"arbeit\", \"arbeit\", \"arbeit\", \"arbeit\", \"arbeit\", \"arbeiten\", \"arbeiten\", \"arbeiten\", \"arbeiten\", \"arbeiten\", \"arbeitskreises\", \"atlanten\", \"aufgaben\", \"aufgaben\", \"aufgaben\", \"aufgaben\", \"aufgaben\", \"auflassen\", \"aufnahme\", \"aufnahme\", \"aufnahme\", \"ausbildung\", \"ausbildung\", \"ausbildung\", \"ausbildung\", \"ausbildung\", \"ausbildung\", \"ausbildungskurs\", \"ausfluge\", \"ausfuhrlicher_bericht\", \"ausgaben\", \"ausgaben\", \"ausgaben\", \"ausgaben\", \"ausschusses\", \"ausschusses\", \"ausschusses\", \"ausschusses\", \"ausschusses\", \"ausschusses\", \"ausschusses\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00df\", \"ausschu\\u00dfsitzung\", \"ausschu\\u00dfsitzung\", \"ausschu\\u00dfsitzung\", \"ausschu\\u00dfsitzung\", \"ausstattung\", \"ausstellung\", \"ausstellung\", \"ausstellung\", \"ausstellung\", \"auswarts\", \"auszeichnung\", \"auszeichnung\", \"auszeichnung\", \"autobusfahrt\", \"autobusse\", \"autographen\", \"autographen\", \"baden\", \"bande\", \"bande\", \"bande\", \"bande\", \"bedienstete\", \"bediensteten\", \"bediensteten\", \"beeinflussen\", \"befinden\", \"befinden\", \"befinden\", \"befinden\", \"beilage\", \"beilage\", \"beirates\", \"beisitzer\", \"beisitzer\", \"benutzen\", \"benutzen\", \"benutzen\", \"benutzen\", \"benutzen\", \"benutzung\", \"benutzung\", \"benutzung\", \"benutzung\", \"beobachter\", \"bereich\", \"bereich\", \"bereich\", \"bereitschaft\", \"bereitschaft\", \"bericht\", \"bericht\", \"bericht\", \"bericht\", \"bericht\", \"bericht\", \"bericht\", \"berichten\", \"berichten\", \"berichten\", \"berichten\", \"berichten\", \"berichten\", \"berichten\", \"berufsstand\", \"berufsstand\", \"beschlie\\u00dfen\", \"beschlie\\u00dfen\", \"beschlie\\u00dfen\", \"beschlie\\u00dfen\", \"beschlie\\u00dfen\", \"beschlie\\u00dfen\", \"besonder\", \"besonder\", \"besonder\", \"besonder\", \"besuches\", \"beteiligung\", \"beteiligung\", \"beteiligung\", \"betrage\", \"betrauen\", \"bezeichnung\", \"bezeichnung\", \"bezugsrecht\", \"bibliographie\", \"bibliographie\", \"bibliographie\", \"bibliographie\", \"bibliographie\", \"bibliographie\", \"bibliographie\", \"bibliothekartag\", \"bibliothekartag\", \"bibliothekartag\", \"bibliothekartag\", \"bibliothekartag\", \"bibliothekartag\", \"bibliothekartag\", \"biblos\", \"biblos\", \"biblos\", \"biblos\", \"biblos\", \"biographie\", \"biologie\", \"bitte_vorzumerken\", \"borsenblatt\", \"bozen\", \"bozen\", \"breinlxx\", \"brief\", \"brief\", \"brief\", \"bringen\", \"bringen\", \"bringen\", \"bringen\", \"bringen\", \"brunner\", \"bucher\", \"bucher\", \"bucher\", \"burgermeister\", \"burgermeister\", \"christine\", \"dankbar\", \"danken\", \"danken\", \"danken\", \"danken\", \"delegieren\", \"delegieren\", \"demgema\\u00df\", \"deutsch\", \"deutsch\", \"deutsch\", \"deutsch\", \"deutsch\", \"deutsch\", \"dicht\", \"dienen\", \"dienen\", \"dienen\", \"dienen\", \"dienen\", \"dienen\", \"dienste\", \"dienstkl\", \"dienstpflichten\", \"dienstprufung\", \"dienstrecht\", \"dienstzweiges\", \"direktor\", \"direktor\", \"direktor\", \"direktor\", \"direktor\", \"diskussien\", \"dissertationen\", \"dissertationen\", \"dissertationen\", \"dogent\", \"dokumentalisten\", \"dokumentation\", \"dokumentation\", \"dokumentation\", \"dokumentation\", \"dokumentation\", \"dokumentation\", \"dokumentation\", \"dollar\", \"dotation\", \"dotation\", \"dringend\", \"druck_osterreichische\", \"druck_osterreichische\", \"druck_osterreichische\", \"druck_osterreichische\", \"druck_osterreichische\", \"druck_osterreichische\", \"druckschriften\", \"druckschriften\", \"druckschriften\", \"druckschriften\", \"durchgefuhrten\", \"durchgefuhrten\", \"ehrenprasident\", \"ehrenzeichen\", \"ehrenzeichen\", \"eigen\", \"eigen\", \"eigen\", \"eigentumer_herausgeber\", \"eigentumer_herausgeber\", \"eigentumer_herausgeber\", \"eigentumer_herausgeber\", \"eigentumer_herausgeber\", \"eigentumer_herausgeber\", \"einbeziehung\", \"einbeziehung\", \"einblicke\", \"einheiten\", \"einreichen\", \"einreichen\", \"einrichten\", \"einrichten\", \"einstimmig\", \"einstimmig\", \"einstimmig\", \"einstimmig\", \"einstimmig\", \"eintragen\", \"einzahlen\", \"einzahlen\", \"einzahlen\", \"einzeln\", \"einzeln\", \"einzeln\", \"einzeln\", \"einzelwerke\", \"einzig\", \"einzig\", \"einzig\", \"eisenstadt\", \"eisenstadt\", \"eisenstadt\", \"eisenstadt\", \"entgegennahme\", \"entlehnungen\", \"entsprechen\", \"entsprechen\", \"entsprechen\", \"erbitten\", \"erbitten\", \"erbitten\", \"erbitten\", \"erbitten\", \"erfolgen\", \"erfolgen\", \"erfolgen\", \"erfolgen\", \"erfolgen\", \"erfolgreich\", \"erfolgreich\", \"erholsam\", \"erlagscheinen\", \"erlernen\", \"erliegen\", \"erliegen\", \"ernst\", \"ernst\", \"erscheinen\", \"erscheinen\", \"erscheinen\", \"erscheinen\", \"erscheinen\", \"erwahnten\", \"erwahnten\", \"erwahnten\", \"erworben\", \"exkursion\", \"fachsitzung\", \"fachsitzung\", \"fachsitzung\", \"fachsitzung\", \"fachversammlung\", \"fachversammlung\", \"fahrkarten\", \"fahrt\", \"fahrt\", \"fahrt\", \"fahrt\", \"fallen\", \"fallen\", \"fallen\", \"fallen\", \"feierlich\", \"feierlichen_eroffnung\", \"feierlichen_eroffnung\", \"finden\", \"finden\", \"finden\", \"finden\", \"finden\", \"finden\", \"finden\", \"firmen\", \"folgen\", \"folgen\", \"folgen\", \"folgen\", \"folgen\", \"folgend\", \"folgend\", \"folgend\", \"folgend\", \"folgend\", \"folgend\", \"folgend\", \"format\", \"forschung\", \"forschung\", \"forschung\", \"forstner\", \"fragen\", \"fragen\", \"fragen\", \"fragen\", \"fragen\", \"fragen\", \"fragen\", \"freier\", \"freistellen\", \"freistellen\", \"fruheren\", \"fuhrung\", \"fuhrung\", \"fuhrung\", \"fuhrung\", \"fuhrung\", \"gamsjagerx\", \"gastgeber\", \"gattin\", \"gattin\", \"gebeten\", \"gebeten\", \"gebeten\", \"gebeten\", \"gebeten\", \"geb\\u00e4ren\", \"gegebenheit\", \"gegensatz\", \"gegensatz\", \"gegenstanden\", \"gegenstanden\", \"gehobenen_dienstes\", \"gehobenen_dienstes\", \"gehobenen_dienstes\", \"gehobenen_dienstes\", \"gehort\", \"gehort\", \"gehort\", \"gehort\", \"gema\\u00df\", \"gema\\u00df\", \"gemeinsam\", \"gemeinsam\", \"gemeinsam\", \"gemeinsam\", \"gemeinsam\", \"gemeinsam\", \"genie\\u00dfen\", \"gerne\", \"gewahlt\", \"gewahlt\", \"gewahlt\", \"gewahlt\", \"gewahlt\", \"gewahlt\", \"gleich\", \"gleich\", \"gleich\", \"grundlichen\", \"halten\", \"halten\", \"halten\", \"halten\", \"halten\", \"halten\", \"halten\", \"hauer\", \"hauptkataloge\", \"hauptreferat\", \"hauptverband\", \"hauptverbandes\", \"hauses\", \"helene\", \"helene\", \"helfern\", \"hilfsmittel\", \"hochsch\", \"hochschule\", \"hochschule\", \"hochschule\", \"hochschule\", \"hoffen\", \"hoffen\", \"hofrat\", \"hofrat\", \"hofrat\", \"hofrat\", \"hofrat\", \"hofrat\", \"hoheren\", \"hoheren\", \"hoheren\", \"hoheren\", \"hoheren\", \"hoheren\", \"horsaal\", \"horsaal\", \"information\", \"information\", \"information\", \"inner\", \"innsbruck\", \"innsbruck\", \"innsbruck\", \"innsbruck\", \"innsbruck\", \"instruktion\", \"interessenten\", \"interessenten\", \"interessenten\", \"interesses\", \"interessieren\", \"interessieren\", \"interessieren\", \"interessieren\", \"interessieren\", \"international\", \"international\", \"international\", \"international\", \"international\", \"international\", \"jahresbeitrag\", \"jahresbeitrag\", \"jahresbeitrag\", \"jancik\", \"jancik\", \"josefsplatz\", \"josefsplatz\", \"josefsplatz\", \"josefsplatz\", \"josefsplatz\", \"jugend\", \"justiz\", \"kassenbericht\", \"kassenbericht\", \"kassenprufer\", \"katalog\", \"katalog\", \"katalog\", \"katalog\", \"kategorie\", \"kenntnis\", \"kenntnis\", \"klaren\", \"klgft\", \"kolark\", \"kollegen\", \"kollegen\", \"kollegen\", \"kollegen\", \"kollegen\", \"kollegen\", \"komitees\", \"kommend\", \"kommend\", \"kommend\", \"kommend\", \"kommend\", \"kommission\", \"kommission\", \"kommission\", \"kommission\", \"kommission\", \"kommission\", \"kommission\", \"kommissionen\", \"kommissionen\", \"kommissionen\", \"kommissionen\", \"kommissionen\", \"konferenz\", \"konferenz\", \"konferenz\", \"konferenz\", \"konferenz\", \"kongresses\", \"kongre\\u00dfgebuhr\", \"konnen\", \"konnen\", \"konnen\", \"konnen\", \"konnen\", \"konnen\", \"konstutierte\", \"kontakt\", \"kontakt\", \"kopplx\", \"kreise\", \"kulturgut\", \"kulturinstitut\", \"kunftiges\", \"kursbesuch\", \"kursbesuches\", \"kursbesuches\", \"kurz\", \"kurz\", \"kurz\", \"kurzer_begru\\u00dfung\", \"kurzfilmen\", \"landes\", \"landes\", \"landes\", \"landes\", \"landes\", \"landesarchiv\", \"landesarchiv_eisenstadt\", \"landesrat\", \"landischen\", \"landwirtschaft\", \"launig\", \"lebendig\", \"lebendig\", \"leitfadens\", \"leitung\", \"leitung\", \"leitung\", \"leitung\", \"leitung\", \"lemmerich\", \"leoben\", \"leoben\", \"leoben\", \"leoben\", \"leoben\", \"librarianship\", \"librarianship\", \"library_association\", \"licht_bildern\", \"linzer\", \"liothekstechnik\", \"lohnen\", \"madden\", \"madden\", \"magnetband\", \"mannern\", \"mappen\", \"mayerhofer\", \"mayerhofer\", \"mayerhofer\", \"mayerhofer\", \"mayerhofer\", \"mayerhofer\", \"mayerhofer\", \"medaille\", \"merlingen\", \"messe\", \"methode\", \"ministerialrat\", \"ministerialrat\", \"ministerialrat\", \"minuten\", \"mitbringen\", \"mitglieder\", \"mitglieder\", \"mitglieder\", \"mitglieder\", \"mitglieder\", \"mitglieder\", \"mitgliederliste\", \"mitgliederliste\", \"mitgliederliste\", \"mitgliederliste\", \"mitgliedern\", \"mitgliedern\", \"mitgliedern\", \"mitgliedern\", \"mitgliedern\", \"mitmachen\", \"mitringer\", \"mitringer\", \"mitteilungen\", \"mitteilungen\", \"mitteilungen\", \"mitteilungen\", \"mitteilungen\", \"mitteilungen\", \"mitteilungen\", \"modifizieren\", \"moglichkeit\", \"moglichkeit\", \"moglichkeit\", \"moglichkeit\", \"moglichkeit\", \"moglichkeit\", \"moglichkeit\", \"morgens\", \"munchen\", \"munchen\", \"munchen\", \"m\\u00fcssen\", \"m\\u00fcssen\", \"m\\u00fcssen\", \"m\\u00fcssen\", \"nachsten\", \"nachsten\", \"nachsten\", \"nachsten\", \"nachsten\", \"nachsten\", \"nachsten\", \"naheren\", \"namen\", \"namen\", \"namen\", \"namen\", \"namen\", \"namen\", \"namen\", \"nehmern\", \"neuwahl\", \"neuwahl\", \"neuwahl\", \"neuwahl\", \"neuwahl\", \"normung\", \"normung\", \"notgemeinschaft\", \"oberosterr\", \"objekte\", \"objekte\", \"offen\", \"offentlichen_privaten\", \"offentlichen_privaten\", \"offentlichen_privaten\", \"ordentlich\", \"ordentlich\", \"ordentlich\", \"ordentlich\", \"ordentliche\", \"ordentliche\", \"ordentliche\", \"ordentliche\", \"organisation\", \"organisation\", \"organisation\", \"organisation\", \"organisation\", \"ornig\", \"ortsublichen\", \"osterr\", \"osterr\", \"osterr\", \"osterr\", \"osterr\", \"osterr\", \"osterr\", \"osterreich\", \"osterreich\", \"osterreich\", \"osterreich\", \"osterreich\", \"osterreich\", \"osterreich\", \"osterreichern\", \"osterreichi_schen\", \"osterreichi_schen\", \"osterreichische\", \"osterreichische\", \"osterreichische\", \"osterreichische\", \"osterreichische\", \"osterreichische\", \"osterreichische\", \"ostlichen\", \"pakete\", \"papyrussammlung\", \"parteienverkehr\", \"person\", \"person\", \"person\", \"person\", \"person\", \"personen\", \"personen\", \"personen\", \"personen\", \"personen\", \"personen\", \"platt\", \"platt\", \"polnisch\", \"polnisch\", \"prachtbau\", \"praktisch\", \"praktisch\", \"praktisch\", \"praktisch\", \"praktisch\", \"prasident\", \"prasident\", \"prasident\", \"prasident\", \"prasident\", \"prasident\", \"prasidium\", \"prasidium\", \"prasidium\", \"prasidium_schriftleitung\", \"prasidium_schriftleitung\", \"preis\", \"preis\", \"preis\", \"preis\", \"preis\", \"preis\", \"preisgrenze\", \"prufungswerber\", \"punkt_tagesordnung\", \"punkt_tagesordnung\", \"punkt_tagesordnung\", \"razumovsky\", \"rechtliche\", \"rechtsfragen\", \"rechtsfragen\", \"regierung\", \"rehberger\", \"reihen\", \"reihen\", \"reihen\", \"reihen\", \"reise\", \"reise\", \"renner\", \"rennhofer\", \"rennhofer\", \"rentabilitat\", \"resolution\", \"resolution\", \"resolution\", \"richten\", \"richten\", \"richten\", \"richten\", \"richten\", \"ruckkehr\", \"sachtitel\", \"sammlung\", \"sammlung\", \"sammlung\", \"sammlung\", \"satzungen\", \"satzungen\", \"satzungen\", \"schaffen\", \"schaffung\", \"schaffung\", \"schaffung\", \"schaft\", \"schaft\", \"schaft\", \"schallplatten\", \"scheidend\", \"scheidend\", \"scheidend\", \"schiff\", \"schildern\", \"schildern\", \"schillingen\", \"schillingen\", \"schlie\\u00dfen\", \"schlie\\u00dfen\", \"schlie\\u00dfen\", \"schlie\\u00dfen\", \"schlie\\u00dfen\", \"schlu\\u00dfsitzung\", \"schlu\\u00dfsitzung\", \"schlu\\u00dfsitzung\", \"schlu\\u00dfsitzung\", \"schrift\", \"schrift\", \"schrift\", \"schrift\", \"schrift\", \"schrift\", \"schriften\", \"schriften\", \"schriften\", \"schriften\", \"schriftfuhrer\", \"schriftfuhrer\", \"schriftfuhrer\", \"schriftfuhrer\", \"schriftfuhrer\", \"schriftfuhrer\", \"schriftfuhrer\", \"sechswochigen\", \"sektion\", \"sendungen\", \"serie\", \"serien\", \"serien\", \"siehe\", \"siehe\", \"siehe\", \"siehe\", \"sitzung\", \"sitzung\", \"sitzung\", \"sitzung\", \"sitzung\", \"sitzung\", \"sitzung\", \"sohin\", \"sondermittel\", \"sonstig\", \"sonstig\", \"sonstig\", \"sonstig\", \"sonstigen_objekte\", \"sorge\", \"soziologie\", \"spanisch\", \"spatestens\", \"sprechen\", \"sprechen\", \"sprechen\", \"sprechen\", \"sprechen\", \"sprechen\", \"stadtbibl\", \"statistik\", \"statistik\", \"statistik\", \"statistik\", \"statistiken\", \"statistiken\", \"statistisch_erfa\\u00dft\", \"stattfinden\", \"stattfinden\", \"stattfinden\", \"stattfinden\", \"stattfinden\", \"stattfinden\", \"stattfinden\", \"stehen\", \"stehen\", \"stehen\", \"stehen\", \"stehen\", \"stehen\", \"stellen\", \"stellen\", \"stellen\", \"stellen\", \"stellen\", \"stellen\", \"stellungnahme\", \"stellungnahme\", \"stellungnahme\", \"stellvertreter\", \"stellvertreter\", \"stellvertreter\", \"stimmen\", \"stimmen\", \"stimmen\", \"strahlen\", \"streichen\", \"streichquartett\", \"stuck\", \"stuck\", \"studentenheim\", \"stummvoll\", \"stummvoll\", \"stummvoll\", \"stummvoll\", \"stummvoll\", \"stundenplan\", \"summe\", \"summe\", \"summe\", \"swoboda\", \"symposium\", \"tagesordnung\", \"tagesordnung\", \"tagesordnung\", \"tagesordnung\", \"tagesordnung\", \"tageszeitungen\", \"tagung\", \"tagung\", \"tagung\", \"tagung\", \"tagung\", \"tagung\", \"tagungsburo\", \"tagungsmappen\", \"tatigkeit\", \"tatigkeit\", \"tatigkeit\", \"tatigkeit\", \"tatigkeit\", \"tatigkeit\", \"tatigkeit\", \"tatsachlichen\", \"tauschzwecke\", \"teilen\", \"teilen\", \"teilen\", \"teilen\", \"teilnehmer\", \"teilnehmer\", \"teilnehmer\", \"teilnehmer\", \"teilnehmer\", \"teilnehmer\", \"teilnehmerzahl\", \"theol\", \"thesen\", \"titel\", \"titel\", \"titel\", \"titel\", \"tonbander\", \"trager\", \"ubersendenden_vollmachten\", \"ubersetzung\", \"uberweisungen\", \"uberwiesen\", \"umfangma\\u00dfig\", \"umgebung\", \"ungarisch\", \"ungarisch\", \"ungarisch\", \"unterbringung\", \"unterbringung\", \"unterricht\", \"unterricht\", \"unterricht\", \"unterricht\", \"unterricht\", \"unterricht\", \"untersuchung\", \"veranstaltern\", \"verbindungsmann\", \"verein\", \"verein\", \"verein\", \"vereines\", \"vereines\", \"vereines\", \"vereinigung\", \"vereinigung\", \"vereinigung\", \"vereinigung\", \"vereinigung\", \"vereinigung\", \"vereinigung\", \"verfasser\", \"verfasser\", \"verfasser\", \"verfassern\", \"verfassers\", \"verlaufen\", \"verleger\", \"verleger\", \"verleger\", \"verleger\", \"verleger\", \"verleger\", \"verlieren\", \"verlieren\", \"verluste\", \"vermehrung\", \"vermehrung\", \"vermerk\", \"verringern\", \"verschieden\", \"verschieden\", \"verschieden\", \"verschieden\", \"verschieden\", \"vodrazka\", \"volkskunde\", \"vollversammlung\", \"volume\", \"vorbereiten\", \"vorbereiten\", \"vorbereiten\", \"vorbereiten\", \"vorbereiten\", \"vorneherein_begrenzte\", \"vorschrift\", \"vorschrift\", \"vorsitzend\", \"vorsitzend\", \"vorsitzend\", \"vorsitzend\", \"vorsitzend\", \"vorsitzend\", \"vorsprache\", \"vorstandes\", \"vorstandes\", \"vorstandes\", \"vorstandes\", \"vorweis\", \"vorziehen\", \"wagen\", \"wahlgang\", \"wahlgang\", \"wahlgangen\", \"wahren\", \"wahren\", \"wahren\", \"wahren\", \"wahren\", \"wahren\", \"werke\", \"werke\", \"werke\", \"werke\", \"wertgrenze\", \"wertvoll\", \"wertvoll\", \"wertvoll\", \"wichtig\", \"wichtig\", \"wichtig\", \"wichtig\", \"wichtig\", \"wichtig\", \"wichtigkeit\", \"wiederaufnahme\", \"wiederaufnahme\", \"wiener\", \"wiener\", \"wiener\", \"wiener\", \"wiener\", \"wiener\", \"wissenschaft_forschung\", \"wissenschaft_forschung\", \"wissenschaftler\", \"worten\", \"worten\", \"worten\", \"xviii\", \"zahlen\", \"zahlen\", \"zahlen\", \"zahlen\", \"zahlen\", \"zdarzil\", \"zdarzil\", \"zeile\", \"zentralbucherei\", \"zessner\", \"zettel\", \"zettel\", \"zetteldrucke\", \"ztgen\", \"zugeordnet\", \"zugmappen\", \"zulassen\", \"zulassung\", \"zulassung\", \"zuruckgelegt\", \"zusammentreten\", \"zwecklos\"]}, \"R\": 30, \"lambda.step\": 0.01, \"plot.opts\": {\"xlab\": \"PC1\", \"ylab\": \"PC2\"}, \"topic.order\": [8, 3, 12, 5, 10, 11, 6, 1, 7, 4, 9, 2], \"corpusinfo\": \"\"};\n", + "\n", + "function LDAvis_load_lib(url, callback){\n", + " var s = document.createElement('script');\n", + " s.src = url;\n", + " s.async = true;\n", + " s.onreadystatechange = s.onload = callback;\n", + " s.onerror = function(){console.warn(\"failed to load library \" + url);};\n", + " document.getElementsByTagName(\"head\")[0].appendChild(s);\n", + "}\n", + "\n", + "if(typeof(LDAvis) !== \"undefined\"){\n", + " // already loaded: just create the visualization\n", + " !function(LDAvis){\n", + " new LDAvis(\"#\" + \"ldavis_el296501403318545376729744612273\", ldavis_el296501403318545376729744612273_data);\n", + " }(LDAvis);\n", + "}else if(typeof define === \"function\" && define.amd){\n", + " // require.js is available: use it to load d3/LDAvis\n", + " require.config({paths: {d3: \"https://d3js.org/d3.v5\"}});\n", + " require([\"d3\"], function(d3){\n", + " window.d3 = d3;\n", + " LDAvis_load_lib(\"https://cdn.jsdelivr.net/gh/bmabey/pyLDAvis@3.3.1/pyLDAvis/js/ldavis.v3.0.0.js\", function(){\n", + " new LDAvis(\"#\" + \"ldavis_el296501403318545376729744612273\", ldavis_el296501403318545376729744612273_data);\n", + " });\n", + " });\n", + "}else{\n", + " // require.js not available: dynamically load d3 & LDAvis\n", + " LDAvis_load_lib(\"https://d3js.org/d3.v5.js\", function(){\n", + " LDAvis_load_lib(\"https://cdn.jsdelivr.net/gh/bmabey/pyLDAvis@3.3.1/pyLDAvis/js/ldavis.v3.0.0.js\", function(){\n", + " new LDAvis(\"#\" + \"ldavis_el296501403318545376729744612273\", ldavis_el296501403318545376729744612273_data);\n", + " })\n", + " });\n", + "}\n", + "</script>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import datetime\n", + "# Plotting tools\n", + "import pyLDAvis\n", + "try:\n", + " import pyLDAvis.gensim # don't skip this\n", + "except ImportError:\n", + " import pyLDAvis.gensim_models as gensimvis\n", + " \n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "NOWSTR = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "\n", + "\n", + "#continue\n", + "lda_model = gensim.models.ldamodel.LdaModel(corpus=dictionary,\n", + " id2word=idword,\n", + " num_topics=12, \n", + " random_state=100,\n", + " update_every=1,\n", + " chunksize=100,\n", + " passes=10,\n", + " alpha='auto',\n", + " per_word_topics=True,\n", + " # distributed=True\n", + " )\n", + "lda_model.save(str(DATA.joinpath(\"{}_lda_single.model\".format(corpusname))))\n", + "# pprint(lda_model.print_topics())\n", + "savelda = str(DATA.joinpath(\"saved_lda_{}_{}.json\".format(corpusname, NOWSTR)))\n", + "visu = gensimvis.prepare(lda_model, dictionary, idword, mds='mmds')\n", + "pyLDAvis.save_json(visu, savelda)\n", + "pyLDAvis.save_html(visu, str(DATA.joinpath(\"saved_lda_{}_{}.html\".format(corpusname, NOWSTR))))\n", + "pyLDAvis.display(visu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now for the tables (datasette)\n", + "\n", + "Sometimes we would have to restart datasette with `systemctl start datasette`..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "corpusname: voeb48-73_\n", + "voeb48-73_20211028-175146 voeb48-73\n", + "loading dict and corpus from data-tw/dict_voeb48-73_20211028-175146.dict, data-tw/corpus_voeb48-73_20211028-175146.mm\n", + "[(2, 0.2805531), (4, 0.026617138), (7, 0.5166085), (9, 0.031186195), (10, 0.1295674), (11, 0.015451236)]\n", + "[(4, 0.0335408), (7, 0.93391645), (9, 0.0260835)]\n", + "[(4, 0.059605595), (7, 0.9234904), (9, 0.016532116)]\n", + "[(2, 0.99909395)]\n", + "[(2, 0.76777035), (10, 0.2285372)]\n", + "[(2, 0.99807)]\n", + "[(2, 0.018939564), (4, 0.05009651), (7, 0.8701947), (9, 0.019532165), (10, 0.041053202)]\n", + "[(2, 0.30289793), (7, 0.38114664), (9, 0.03813178), (10, 0.27691138)]\n", + "[(4, 0.032640114), (7, 0.935043), (9, 0.02452857)]\n", + "[(4, 0.0550239), (7, 0.93037254), (9, 0.014232905)]\n", + "[(2, 0.9990953)]\n", + "[(2, 0.7647797), (10, 0.23157236)]\n", + "[(2, 0.8355817), (7, 0.11142462), (9, 0.023192778), (10, 0.0131209195), (11, 0.016423883)]\n", + "[(2, 0.46640286), (4, 0.040240686), (7, 0.271938), (9, 0.04701706), (10, 0.09569729), (11, 0.078543805)]\n", + "[(2, 0.092409864), (4, 0.04902445), (7, 0.78285456), (9, 0.054846834), (10, 0.02074028)]\n", + "[(2, 0.112780854), (4, 0.02586087), (7, 0.82400656), (9, 0.029357133)]\n", + "[(2, 0.6328255), (7, 0.34989017), (11, 0.016721573)]\n", + "[(2, 0.1505291), (4, 0.024832528), (7, 0.7936737), (10, 0.018778518)]\n", + "[(2, 0.32843506), (4, 0.040555365), (7, 0.53169554), (9, 0.043821767), (11, 0.047176685)]\n", + "[(2, 0.40401903), (4, 0.06405743), (7, 0.36368492), (9, 0.021000203), (10, 0.013611786), (11, 0.13355342)]\n", + "[(2, 0.3361721), (4, 0.14966382), (7, 0.36112234), (9, 0.030305833), (10, 0.034698848), (11, 0.087940045)]\n", + "[(2, 0.5824958), (4, 0.08177448), (10, 0.33350626)]\n", + "[(2, 0.56737334), (4, 0.099197485), (7, 0.20318973), (9, 0.023298362), (11, 0.10680778)]\n", + "[(2, 0.12868905), (4, 0.06824589), (7, 0.49881265), (9, 0.2887983), (10, 0.014769213)]\n", + "[(2, 0.62545335), (4, 0.12095001), (7, 0.07840649), (10, 0.06259749), (11, 0.11221576)]\n", + "[(2, 0.14459576), (4, 0.0936272), (9, 0.01156143), (11, 0.7498722)]\n", + "[(2, 0.45956668), (4, 0.06435885), (6, 0.07969774), (7, 0.16556579), (9, 0.06613689), (10, 0.03169823), (11, 0.13275075)]\n", + "[(2, 0.0347122), (11, 0.96488273)]\n", + "[(2, 0.088310905), (4, 0.062799305), (5, 0.014985357), (7, 0.15732811), (9, 0.028218329), (10, 0.039133493), (11, 0.6091809)]\n", + "[(2, 0.13958132), (4, 0.03976587), (7, 0.09445578), (9, 0.07991784), (10, 0.0612161), (11, 0.5847389)]\n", + "[(2, 0.43281084), (4, 0.100822575), (7, 0.03893598), (9, 0.026698781), (10, 0.28327924), (11, 0.11717471)]\n", + "[(2, 0.7818935), (4, 0.14960098), (7, 0.06715488)]\n", + "[(2, 0.90718), (4, 0.046793427), (9, 0.045456998)]\n", + "[(2, 0.34763563), (4, 0.3842686), (7, 0.09916011), (9, 0.034207687), (10, 0.07952978), (11, 0.055022098)]\n", + "[(4, 0.042264383), (7, 0.858117), (9, 0.09142882)]\n", + "[(4, 0.052148297), (7, 0.48781973), (9, 0.45966977)]\n", + "[(4, 0.055325173), (7, 0.49083987), (9, 0.45347628)]\n", + "[(2, 0.023911085), (4, 0.120421834), (7, 0.4024756), (9, 0.23378178), (10, 0.12844229), (11, 0.09075342)]\n", + "[(2, 0.36894888), (4, 0.04179211), (7, 0.1389178), (9, 0.041064333), (10, 0.40913212)]\n", + "[(2, 0.3261571), (4, 0.09141748), (7, 0.06889465), (10, 0.40162906), (11, 0.111012295)]\n", + "[(2, 0.24502474), (4, 0.1662812), (7, 0.10007411), (9, 0.057046663), (10, 0.06392365), (11, 0.36729845)]\n", + "[(4, 0.03527757), (7, 0.8000644), (9, 0.13965479), (10, 0.016864482)]\n", + "[(4, 0.046740916), (9, 0.068160124), (11, 0.87861127)]\n", + "[(4, 0.26713732), (7, 0.70290494), (10, 0.028992627)]\n", + "[(4, 0.09300666), (7, 0.7673158), (9, 0.13829629)]\n", + "[(4, 0.022928521), (9, 0.032768436), (10, 0.011241415), (11, 0.93288296)]\n", + "[(2, 0.25791875), (4, 0.11015291), (7, 0.2376752), (11, 0.39120385)]\n", + "[(2, 0.1337724), (4, 0.18047144), (5, 0.1493544), (7, 0.2036052), (10, 0.14679994), (11, 0.18432277)]\n", + "[(2, 0.3362658), (4, 0.48107362), (7, 0.18136439)]\n", + "[(2, 0.68358207), (4, 0.1382686), (7, 0.07193991), (9, 0.034910206), (10, 0.043409046), (11, 0.020519607)]\n", + "[(2, 0.09697018), (4, 0.2164108), (7, 0.2175626), (9, 0.0722713), (11, 0.39592153)]\n", + "[(4, 0.17859197), (7, 0.71225655), (9, 0.07464845), (10, 0.034257855)]\n", + "[(4, 0.16188428), (7, 0.7660489), (9, 0.071355864)]\n", + "[(4, 0.47196886), (7, 0.47376692), (9, 0.053329516)]\n", + "[(2, 0.83459514), (4, 0.09010547), (9, 0.0745168)]\n", + "[(2, 0.26260626), (4, 0.20297582), (5, 0.06683364), (7, 0.09248767), (9, 0.053551324), (11, 0.32117915)]\n", + "[(2, 0.0151258465), (4, 0.0487812), (5, 0.01280832), (7, 0.84131074), (9, 0.076691516)]\n", + "[(2, 0.39000282), (4, 0.18601581), (5, 0.06887991), (7, 0.15141004), (9, 0.07428958), (11, 0.12027027)]\n", + "[(2, 0.31650478), (4, 0.24970184), (5, 0.046464406), (7, 0.13724995), (10, 0.24818428)]\n", + "[(4, 0.22466533), (6, 0.117342986), (7, 0.09998731), (10, 0.16637614), (11, 0.38846293)]\n", + "[(2, 0.09362584), (3, 0.1238802), (4, 0.3593046), (7, 0.3338605), (9, 0.088648304)]\n", + "[(0, 0.22675493), (2, 0.06712009), (4, 0.31200948), (7, 0.2582018), (9, 0.066289075), (10, 0.06149375)]\n", + "[(0, 0.22614719), (4, 0.36301723), (7, 0.33477435), (9, 0.07516922)]\n", + "[(2, 0.53701824), (4, 0.3603416), (5, 0.04599441), (10, 0.055573378)]\n", + "[(2, 0.3383623), (4, 0.17071772), (5, 0.28385293), (7, 0.17929342), (9, 0.026837116)]\n", + "[(2, 0.35674962), (4, 0.37027392), (7, 0.15435497), (9, 0.05567779), (10, 0.046111044), (11, 0.016374981)]\n", + "[(2, 0.400412), (4, 0.09259629), (7, 0.1721627), (9, 0.33391258)]\n", + "[(2, 0.36706805), (4, 0.06187569), (7, 0.11543792), (9, 0.40301746), (10, 0.012816688), (11, 0.039422754)]\n", + "[(2, 0.14874376), (4, 0.123410955), (7, 0.2002042), (9, 0.394779), (10, 0.13235474)]\n", + "[(7, 0.14047143), (9, 0.084204175), (10, 0.7734269)]\n", + "[(4, 0.6215544), (7, 0.042740345), (9, 0.105777524), (10, 0.08722626), (11, 0.14207742)]\n", + "[(0, 0.020146385), (4, 0.2174245), (7, 0.29464835), (9, 0.20780663), (11, 0.2591272)]\n", + "[(2, 0.39141038), (4, 0.5413344), (10, 0.06588475)]\n", + "[(2, 0.29253194), (4, 0.14046106), (5, 0.27256966), (7, 0.08628638), (9, 0.17593509), (11, 0.03168814)]\n", + "[(2, 0.091311015), (4, 0.22958764), (9, 0.1416632), (10, 0.040435653), (11, 0.49630657)]\n", + "[(2, 0.32591188), (4, 0.14575388), (5, 0.010086877), (7, 0.10935142), (9, 0.10230067), (10, 0.26048017), (11, 0.045984503)]\n", + "[(9, 0.024144225), (11, 0.97554266)]\n", + "[(2, 0.182749), (4, 0.48231214), (7, 0.100606464), (9, 0.07756725), (10, 0.026663717), (11, 0.12979878)]\n", + "[(2, 0.24598487), (4, 0.28187233), (7, 0.12888093), (9, 0.11054232), (10, 0.23169671)]\n", + "[(2, 0.373515), (4, 0.18770917), (5, 0.020417225), (7, 0.1690224), (9, 0.12493417), (10, 0.11487046)]\n", + "[(2, 0.37631118), (4, 0.20933467), (5, 0.21088243), (7, 0.03913531), (9, 0.16323185)]\n", + "[(2, 0.33449683), (4, 0.045258284), (9, 0.22064714), (11, 0.3981758)]\n", + "[(2, 0.2638961), (4, 0.5413212), (7, 0.107675515), (9, 0.031046528), (10, 0.055511333)]\n", + "[(4, 0.0828329), (7, 0.64052755), (9, 0.21048824), (10, 0.062462017)]\n", + "[(2, 0.043114707), (4, 0.2607085), (7, 0.23128694), (10, 0.43940273), (11, 0.021594316)]\n", + "[(2, 0.36785796), (4, 0.1603459), (9, 0.44459584), (10, 0.025889214)]\n", + "[(2, 0.28757623), (4, 0.15526289), (7, 0.15263833), (8, 0.0376659), (9, 0.27751094), (10, 0.08849836)]\n", + "[(2, 0.39055955), (4, 0.58292824), (5, 0.02370643)]\n", + "[(4, 0.17245817), (7, 0.16922893), (9, 0.6537295)]\n", + "[(2, 0.7588662), (4, 0.07487608), (5, 0.040221617), (9, 0.064358346), (10, 0.061249927)]\n", + "[(2, 0.33220628), (4, 0.05561143), (5, 0.43853623), (9, 0.17216116)]\n", + "[(2, 0.28272012), (4, 0.18492875), (5, 0.07377189), (7, 0.21272132), (9, 0.052982252), (10, 0.19233702)]\n", + "[(2, 0.21442762), (4, 0.4965944), (7, 0.08489679), (9, 0.1397767), (11, 0.06360585)]\n", + "[(2, 0.29686487), (4, 0.12553315), (9, 0.07112925), (10, 0.013048349), (11, 0.4931021)]\n", + "[(2, 0.78269356), (4, 0.10137049), (9, 0.115548015)]\n", + "[(2, 0.2884586), (4, 0.1481043), (7, 0.17265686), (9, 0.31642842), (11, 0.07348688)]\n", + "[(2, 0.409713), (4, 0.17038544), (7, 0.08065667), (9, 0.25919116), (10, 0.027758613), (11, 0.05205198)]\n", + "[(2, 0.21934862), (4, 0.16837862), (7, 0.08992787), (9, 0.08549616), (10, 0.40364566), (11, 0.032902677)]\n", + "[(2, 0.4154466), (4, 0.34010348), (7, 0.13885087), (9, 0.08750115), (11, 0.01742183)]\n", + "[(2, 0.17591386), (4, 0.29826498), (7, 0.0637388), (9, 0.098285966), (10, 0.3572086)]\n", + "[(5, 0.9466116), (9, 0.051640823)]\n", + "[(4, 0.9819012), (10, 0.016341466)]\n", + "[(2, 0.03543197), (4, 0.9460082), (11, 0.015636228)]\n", + "[(4, 0.010969139), (5, 0.22666751), (9, 0.7608348)]\n", + "[(4, 0.013159093), (9, 0.9839817)]\n", + "[(4, 0.9210771), (9, 0.077488765)]\n", + "[(4, 0.088405326), (9, 0.91085476)]\n", + "[(4, 0.5857286), (9, 0.40695855)]\n", + "[(9, 0.07238506), (10, 0.92089194)]\n", + "[(4, 0.010254808), (9, 0.9852471)]\n", + "[(4, 0.94235295), (9, 0.05665622)]\n", + "[(9, 0.9980122)]\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'Series' object has no attribute 'columns'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_29650/1374924362.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mdf_topic_sent_keywords\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtm_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_topics_sentences\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mldamodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlda_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcorpus\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcorpus\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtexts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf_topic_sent_keywords\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0mdf_topic_sent_keywords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Dominant_Topic'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf_topic_sent_keywords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Dominant_Topic'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfillna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# Format\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/tljh/user/lib/python3.7/site-packages/pandas/core/generic.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 5463\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5464\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5465\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5466\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5467\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'Series' object has no attribute 'columns'" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n", + "/opt/tljh/user/lib/python3.7/site-packages/past/builtins/misc.py:45: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses\n", + " from imp import reload\n" + ] + } + ], + "source": [ + "# what topic a given document is about\n", + "data_lemmatized = tm_utils.get_lemmatized(corpusname=corpusname, datadir=DATA)\n", + "id2word, corpus = tm_utils.get_corpus_dictionary(data_lemmatized, \n", + " corpusname=corpusname, save=False, \n", + " datadir=DATA, from_file=True)\n", + "\n", + "# above:\n", + "lda_model = gensim.models.LdaModel.load(str(DATA.joinpath(\"{}_lda_single.model\".format(corpusname))))\n", + "# watch out: data is source data, not lemmatized data!\n", + "raw_df = pd.read_csv(DATA.joinpath(\"voeb_48-73.csv\"), sep=\";\")\n", + "data = raw_df['text'].to_list()\n", + "\n", + "# we should create a column with the date/vol in it (also necessary for timeline)\n", + "\n", + "df_topic_sent_keywords = tm_utils.format_topics_sentences(ldamodel=lda_model, corpus=corpus, texts=data)\n", + "print(df_topic_sent_keywords.columns)\n", + "df_topic_sent_keywords['Dominant_Topic'] = df_topic_sent_keywords['Dominant_Topic'].fillna(0).apply(lambda x: str(int(x)))\n", + "# Format\n", + "df_dominant_topic = df_topic_sent_keywords.reset_index()\n", + "df_dominant_topic.columns = ['Document_No', 'Dominant_Topic', 'Topic_Perc_Contrib', 'Keywords', 'Text']\n", + "df_dominant_topic.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table voeb_48-73_dominant_topics in jbekesi.db updated/created\n", + "saved.\n" + ] + } + ], + "source": [ + "output_table = \"voeb_48-73_dominant_topics\"\n", + "output_csv = str(DATA.joinpath(f\"{output_table}.csv\"))\n", + "df_dominant_topic.to_csv(output_csv, sep=\";\", index=False)\n", + "tm_utils.csv_to_datasette(tablename=output_table, csv=output_csv, db=None)\n", + "print(\"saved.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Most representative topic\n", + "\n", + "Sometimes just the topic keywords may not be enough to make sense of what a topic is about. So, to help with understanding the topic, you can find the documents a given topic has contributed to the most and infer the topic by reading that document." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table voeb48-73_most_representative_topics in jbekesi.db updated/created\n" + ] + } + ], + "source": [ + "most_repr = pd.DataFrame()\n", + "\n", + "sent_topics_outdf_grpd = df_topic_sent_keywords.groupby('Dominant_Topic')\n", + "\n", + "for i, grp in sent_topics_outdf_grpd:\n", + " most_repr = pd.concat([most_repr, grp.sort_values(['Perc_Contribution'], ascending=[0]).head(1)], \n", + " axis=0)\n", + "\n", + "# Reset Index \n", + "most_repr.reset_index(inplace=True)\n", + "most_repr.set_index('index', drop=False, inplace=True)\n", + "#sent_topics_sorteddf_mallet.reset_index(drop=True, inplace=True)\n", + "# Format\n", + "most_repr.columns = ['Document_No','Topic_Num', \"Topic_Perc_Contrib\", \"Keywords\", \"Text\"]\n", + "\n", + "# Show\n", + "most_repr.head()\n", + "output_table = \"{}_most_representative_topics\".format(corpusname)\n", + "output_csv = str(DATA.joinpath(output_table + \".csv\"))\n", + "most_repr.to_csv(put_csv, sep=\";\", index=False)\n", + "tm_utils.csv_to_datasette(tablename=output_table, csv=output_csv, db=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Topic distribution across documents\n", + "\n", + "Finally, we want to understand the volume and distribution of topics in order to judge how widely it was discussed. The below table exposes that information." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table voeb48-73_distribution_of_topics in jbekesi.db updated/created\n" + ] + } + ], + "source": [ + "# Number of Documents for Each Topic\n", + "topic_counts = df_topic_sent_keywords['Dominant_Topic'].value_counts()\n", + "\n", + "# Percentage of Documents for Each Topic\n", + "topic_contribution = round(topic_counts/topic_counts.sum(), 4)\n", + "\n", + "# Topic Number and Keywords\n", + "topic_num_keywords = df_topic_sent_keywords[['Dominant_Topic', 'Topic_Keywords']]\n", + "\n", + "# Concatenate Column wise\n", + "df_dominant_topics = pd.concat([topic_num_keywords, topic_counts, topic_contribution], axis=1)\n", + "\n", + "# drop all rows w/out values\n", + "# print(df_dominant_topics.columns)\n", + "#df_dominant_topics.dropna(inplace=True, thresh=2) # = df_dominant_topics[df_dominant_topics.columns[[-2]] != 0]\n", + "\n", + "# Change Column names\n", + "df_dominant_topics.columns = ['Dominant_Topic', 'Topic_Keywords', 'Num_Documents', 'Perc_Documents']\n", + "\n", + "# Show\n", + "# df_dominant_topics\n", + "output_table = \"{}_distribution_of_topics\".format(corpusname)\n", + "output_csv = str(DATA.joinpath(output_table + \".csv\"))\n", + "df_dominant_topics.to_csv(output_csv, sep=\";\", index=False)\n", + "tm_utils.csv_to_datasette(tablename=output_table, csv=output_csv, db=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Time series (years, months/vols)\n", + "\n", + "Have to re-read src df/csv\n", + "\n", + "for each document we need the topic distribution (i.e. percentage of each topic for this doc)\n", + "\n", + "this should be in model data; good to have a function doing this.\n", + "\n", + "we did this for anno material (newspapers) -- but it was mallet-generated, i.e. for every\n", + " document there is a list of topic contribution percentages (not for gensim generated ones)\n", + " \n", + "ok, there is one for gensim, too, but gensim throws away those topics below `minimum_probability=0.01` (default)\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "corpusname: voeb48-73_\n", + "voeb48-73_20210308-095808 voeb48-73\n", + "loading dict and corpus from data/dict_voeb48-73_20210303-175249.dict, data/corpus_voeb48-73_20210303-175249.mm\n" + ] + } + ], + "source": [ + "#\n", + "# ok, we use mallet for this until we know how to reproduce it with gensim...\n", + "# \n", + "data_lemmatized = tm_utils.get_lemmatized(corpusname=corpusname, datadir=DATA)\n", + "id2word, corpus = tm_utils.get_corpus_dictionary(data_lemmatized, \n", + " corpusname=corpusname, save=False, \n", + " datadir=DATA, from_file=True)\n", + "mallet_binary=\"/usr/local/bin/mallet-2.0.8/bin/mallet\"\n", + "# lda_model = gensim.models.wrappers.LdaMallet(mallet_binary, corpus=corpus, num_topics=20, id2word=id2word,\n", + "# prefix=str(DATA.joinpath(\"./models/\").resolve()))\n", + "\n", + "# above:\n", + "# lda_model = gensim.models.LdaModel.load(str(DATA.joinpath(\"{}_lda_single.model\".format(corpusname))))\n", + "lda_model = gensim.models.ldamodel.LdaModel(corpus=corpus,\n", + " id2word=id2word,\n", + " num_topics=12, \n", + " random_state=100,\n", + " update_every=1,\n", + " chunksize=100,\n", + " passes=30,\n", + " alpha='auto',\n", + " per_word_topics=False,\n", + " minimum_probability=0.001,\n", + " # distributed=True\n", + " )\n", + "\n", + "# watch out: data is source data, not lemmatized data!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "making `gensim` generated data work for time series" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(112, 5)\n", + "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n" + ] + } + ], + "source": [ + "raw_df = pd.read_csv(DATA.joinpath(\"voeb_48-73.csv\"), sep=\";\")\n", + "print(raw_df.shape)\n", + "topic_no = 12\n", + "# print(lda_model.show_topics(topic_no))\n", + "topics = {}\n", + "topic_headers = []\n", + "trow_templ = [0 for x in range(topic_no)]\n", + "print(trow_templ)\n", + "# collect topic words\n", + "for t in lda_model.show_topics(num_topics=topic_no, num_words=10, log=False, formatted=False):\n", + " tnum = t[0]\n", + " tl = t[1]\n", + " topics[tnum] = \", \".join([word for word, prop in tl])\n", + " topic_headers.append(f\"topic_{tnum}\")\n", + "#create an array for use in time series\n", + "data = []\n", + "for i, row in enumerate(lda_model[corpus]):\n", + " # the format of each row representing a document is:\n", + " # 1) list of topic numbers with percentage of contributing to document\n", + " # output: index year-month topic0 topic2 topic3... topic11\n", + " values = trow_templ[:]\n", + " #if i > 4:\n", + " # break\n", + " year = raw_df.loc[i]['year']\n", + " month = raw_df.loc[i]['month']\n", + " vol = raw_df.loc[i]['vol']\n", + " topic_values = {}\n", + " # print(len(row))\n", + " for r in row:\n", + " topic_idx, val = r\n", + " values[topic_idx] = val\n", + " #print(row, year, month, vol)\n", + " #print( values)\n", + " data.append([year, month, vol] + values)\n", + " #print(\"\\n\")\n", + "df = pd.DataFrame(data, columns=[\"year\", 'month', \"vol\"] + topic_headers)\n", + "timeseries = f\"{corpusname}_time.csv\"\n", + "df.to_csv(DATA.joinpath(timeseries), sep=\";\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " year month vol topic_0 topic_1 topic_2 topic_3 topic_4 topic_5 \\\n", + "0 1948 6 ap 0.931631 0 0.000000 0.004572 0.0 0.0 \n", + "1 1949 11 NaN 0.912286 0 0.056984 0.000000 0.0 0.0 \n", + "2 1949 12 NaN 0.509525 0 0.412236 0.008070 0.0 0.0 \n", + "3 1950 2 1 0.001128 0 0.843544 0.000000 0.0 0.0 \n", + "4 1950 2 1 0.009117 0 0.842450 0.000000 0.0 0.0 \n", + "\n", + " topic_6 topic_7 topic_8 topic_9 topic_10 topic_11 \n", + "0 0.063767 0.0 0.0 0 0.0 0.0 \n", + "1 0.030419 0.0 0.0 0 0.0 0.0 \n", + "2 0.069936 0.0 0.0 0 0.0 0.0 \n", + "3 0.155156 0.0 0.0 0 0.0 0.0 \n", + "4 0.148261 0.0 0.0 0 0.0 0.0 \n", + "12 Topics\n", + "col: 3 topic: 0 maxval: 0.9696415066719056\n", + "xval: 21 for topic 0 (max: 0.9696415066719056)\n", + "col: 4 topic: 1 maxval: 0\n", + "xval: None for topic 1 (max: 0)\n", + "col: 5 topic: 2 maxval: 0.8435437679290771\n", + "xval: 3 for topic 2 (max: 0.8435437679290771)\n", + "col: 6 topic: 3 maxval: 0.9871073365211488\n", + "xval: 107 for topic 3 (max: 0.9871073365211488)\n", + "col: 7 topic: 4 maxval: 0.2576159238815308\n", + "xval: 82 for topic 4 (max: 0.2576159238815308)\n", + "col: 8 topic: 5 maxval: 0.19430546462535855\n", + "xval: 56 for topic 5 (max: 0.19430546462535855)\n", + "col: 9 topic: 6 maxval: 0.9993466138839722\n", + "xval: 108 for topic 6 (max: 0.9993466138839722)\n", + "col: 10 topic: 7 maxval: 0.7052674889564514\n", + "xval: 5 for topic 7 (max: 0.7052674889564514)\n", + "col: 11 topic: 8 maxval: 0.4689945578575134\n", + "xval: 36 for topic 8 (max: 0.4689945578575134)\n", + "col: 12 topic: 9 maxval: 0\n", + "xval: None for topic 9 (max: 0)\n", + "col: 13 topic: 10 maxval: 0.605548083782196\n", + "xval: 45 for topic 10 (max: 0.605548083782196)\n", + "col: 14 topic: 11 maxval: 0.173262819647789\n", + "xval: 39 for topic 11 (max: 0.173262819647789)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 4000x4000 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "timeseries = f\"{corpusname}_time.csv\"\n", + "\n", + "data = pd.read_csv(DATA.joinpath(timeseries), sep=\";\")\n", + "data = data.sort_values(by=[\"year\", \"month\", \"vol\"], ignore_index=True) # sorting \n", + "data = data.reset_index(drop=True)\n", + "print(data.head())\n", + "imgdir = DATA.joinpath(\"images\")\n", + "x = range(0, data.shape[0])\n", + "data['publ'] = data['year'].fillna(\"\").apply(lambda x: str(x))\n", + "data['year_month'] = pd.to_datetime(data['year'].map(str) + \"-\" + data['month'].map(str)) \n", + "#data['year'].fillna(0).apply(lambda x: \n", + "# pd.to_datetime(df['birth_date'](x))\n", + "# data['publ'] = data['publ'].str.cat(data[['month']], sep='-', na_rep=\"\")\n", + "x = list(data['year_month'])\n", + "# y = data\n", + "chunksize = 4\n", + "print(len(topics), \"Topics\")\n", + "variant = \"\"\n", + "plt.figure(figsize=[20,20], dpi=200)\n", + "for j in range(0, int(len(topics)/chunksize)):\n", + " plt.subplot(511+j)\n", + " for i in range(0, chunksize):\n", + " col = i + chunksize * j\n", + " col_topic_idx = col + 3\n", + " maxval = max(data.iloc[:, col_topic_idx])\n", + " print(\"col:\", col_topic_idx, \"topic: \", col, \"maxval:\", maxval)\n", + " if maxval:\n", + " xval = data.loc[data[f'topic_{col}'] == maxval].index.item()\n", + " else:\n", + " xval = None\n", + " print(\"xval: {} for topic {} (max: {})\".format(xval, col, maxval))\n", + " descr = \", \".join(topics[col].split(\", \")[:4])\n", + " src = \"\"\n", + " label=\"Topic {}: {}... {}\".format(col+1, descr, src)\n", + " if xval:\n", + " plt.annotate(\"x_{}\".format(col + 1), (int(xval), maxval)) # annotate max value for topic \n", + " plt.plot(x, data.iloc[:, col_topic_idx], label=label)\n", + " plt.legend()\n", + " plt.xlabel(\"VOEB 1948-{} ({} volumes)\".format(year, data.shape[0]))\n", + " plt.ylabel(\"Topic percentage / 100\")\n", + " # plt.xlim(-18, 700)\n", + "plt.autoscale(enable=True, axis=\"x\")\n", + "plt.savefig(str(imgdir.joinpath(\"voeb_{}_topics_{}_1-20.png\".format(year, variant))) )\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}