upd: Make changes requested by editor review results

data/processed_data/word2vec_models/italian.txt

+Due to file size limitations, we had to move the pretrained models to another repository.
+Please download the pickled model here: http://gams.uni-graz.at/o:dispecs.word2vec.it/ITALIAN
\ No newline at end of file

data/processed_data/word2vec_models/spanish.txt

+Due to file size limitations, we had to move the pretrained models to another repository.
+Please download the pickled model here: http://gams.uni-graz.at/o:dispecs.word2vec.es/SPANISH
\ No newline at end of file

data/word2vec/models/french.txt

-Due to file size limitation on GitHub, we had to move the pretrained models to Google Drive.
-Please download the pickled model here: https://drive.google.com/file/d/15ChW1dipL2ULU-yaa5oXN-ZUJ00HW5VV/view?usp=sharing
\ No newline at end of file

data/word2vec/models/italian.txt

-Due to file size limitation on GitHub, we had to move the pretrained models to Google Drive.
-Please download the pickled model here: https://drive.google.com/file/d/14O2s3x9ZEG3Zx-SVA6LcDScpZuSAosiJ/view?usp=sharing
\ No newline at end of file

data/word2vec/models/spanish.txt

-Due to file size limitation on GitHub, we had to move the pretrained models to Google Drive.
-Please download the pickled model here: https://drive.google.com/file/d/1SME9EMCF8dnSJU458kaoV1dZUmgNHMel/view?usp=sharing
\ No newline at end of file

publication.ipynb

 %% Cell type:markdown id: tags:
 
 # A Sentiment Analysis Tool Chain for 18<sup>th</sup> Century Periodicals
 
 *Philipp Koncar, Christina Glatz, Elisabeth Hobisch, Yvonne Völkl, Bernhard C. Geiger, Sanja Sarić, Martina Scholger, Denis Helic*
 
 %% Cell type:markdown id: tags:
 
 ## Introduction
 
 Sentiment analysis is a common task in natural language processing (NLP) and aims for the automatic and computational identification of emotions, attitudes and opinions expressed in textual data (Pang et al. 2008). While Sentiment analysis is especially tailored for and widely used in the context of social media analysis and other web data, such as product reviews (Pak and Paroubek 2010, Ortigosa et al. 2014, Hamilton et al. 2016), the application to literary texts is still challenging due to the lack of methods - with few but notable exceptions (Schmidt et al. 2018; Sprugnoli et al. 2020) - dedicated to languages other than English and from earlier times.
 In the currently ongoing project [^1] Distant Reading for Periodicals of the Enlightenment (DiSpecs - [link to project website](http://gams.uni-graz.at/dispecs)) funded by the Austrian Academy of Sciences, we analyze Spectator periodicals from the Digital Edition project The Spectators in the International Context (Ertler et al. 2011) in terms of their thematic, stylistic, and emotional orientation using different computational methods, including sentiment analysis. During the project, it became obvious that existing methods are only partly suitable for 18<sup>th</sup> century texts which comprise the spectatorial press. In particular, we encountered problems with shifts in word meanings and spellings between modern day and 18<sup>th</sup> century languages. Therefore, we concluded that the development of appropriate methods for 18<sup>th</sup> century texts is necessary to further improve the quality of our analyses. Additional funding by CLARIAH-AT made this endeavour possible.
 
 With the contribution presented here, we not only introduce new sentiment dictionaries for French, Italian and Spanish texts of the 18<sup>th</sup> century, but also build a freely and publicly available tool chain based on Jupyter Notebooks, enabling researchers to apply our dictionary creation process and sentiment analysis methods to their own material and projects. Our Notebooks furthermore contain tutorial-style introductions to concepts such as word embeddings, k-nearest neighbor classification, and dictionary-based sentiment analysis.
 
 The proposed tool chain comprises two different parts: (i) the optional creation of sentiment dictionaries and (ii) the actual sentiment analysis.
 More precisely, the first part requires manual annotations of seed words from which we transfer sentiment to other words occurring in a similar context as seed words. To transfer sentiment, we train word embeddings and use a machine learning classification task. In doing so, we computationally extend the list of annotated words and avoid a more time-consuming and tedious manual annotation process. Note that this procedure is also adaptable to other languages (also contemporary languages).
 In the second part, we provide a collection of ready-to-use sentiment dictionaries (which we created with the first part of the tool chain) as well as methods to perform the actual sentiment analysis. The implemented methods range from listing basic descriptive statistics to various kinds of plots that allow for an easy interpretation of sentiment expressed in a given text corpus. Further, our methods analyze sentiment on a macro- and microscopic level, as they can not only be applied to a whole corpus providing a bigger picture of data, but also on a document level, for example, by highlighting words that convey sentiment in any given text.
 
-This repository contains all the data we used for creating sentiment dictionaries, including manually annotated seed words, pre-trained word embedding models and other data resulting from intermediate steps. These can also be used in other contexts and NLP tasks and are not necessarily limited to sentiment analysis. As such, our tool chain serves as a foundation for further methods and approaches applicable to all projects focusing on the computational interpretation of texts.
+This repository contains all the data we used for creating sentiment dictionaries, including manually annotated seed words, pretrained word embedding models and other data resulting from intermediate steps. These can also be used in other contexts and NLP tasks and are not necessarily limited to sentiment analysis. As such, our tool chain serves as a foundation for further methods and approaches applicable to all projects focusing on the computational interpretation of texts.
 
 Before we continue, please import the necessary Python Packages for the interactive examples:
 
 %% Cell type:code id: tags:
 
 ``` python
 import pandas
 import matplotlib.pyplot as plt
-import gensim.downloader as api
 import nltk
 import seaborn
 import re
 from nltk.tokenize import WordPunctTokenizer
-from mpl_toolkits.mplot3d import Axes3D
 from sklearn.feature_extraction.text import CountVectorizer
 from sklearn.neighbors import KNeighborsClassifier
 from gensim.models.word2vec import Word2Vec
 from IPython.display import display, HTML, Markdown
 ```
 
 %% Cell type:markdown id: tags:
 
-Additionally, please execute the following cell to download data (i.e., the Punkt tokenizer and the text8 corpus) provided by NLTK and Gensim which is necessary for the examples presented in this Notebook:
+Additionally, please execute the following cell to download data (i.e., the Punkt tokenizer) provided by NLTK which is necessary for the examples presented in this Notebook:
 
 %% Cell type:code id: tags:
 
 ``` python
 nltk.download('punkt')
-word2vec_example_corpus = api.load("text8")
 ```
 
 %%%% Output: stream
 
     [nltk_data] Downloading package punkt to
     [nltk_data]     /Users/philippkoncar/nltk_data...
     [nltk_data]   Package punkt is already up-to-date!
 
+%%%% Output: execute_result
+
+    True
+
 %% Cell type:markdown id: tags:
 
 [^1]: A cooperation between the Institute for Interactive Systems and Data Science at Graz University of Technology, the Know-Center GmbH as well as the Centre for Information Modelling - Austrian Centre for Digital Humanities (ZIM-ACDH) and the Institute of Romance Studies, both at the University of Graz.
 
 %% Cell type:markdown id: tags:
 
 ## Sentiment Dictionaries for the 18<sup>th</sup> Century
 
 In this section, we describe the process of how we created sentiment dictionaries and provide examples for the underlying methods. Please proceed with the *Sentiment Analysis for the 18<sup>th</sup> Century* section if you want to use our ready-to-use dictionaries for French, Italian and Spanish of the 18<sup>th</sup> century.
 The Jupyter Notebooks, which can be easily used by everyone to create sentiment dictionaries for their own projects, can be found in the `code/dictionary_creation/` directory of this repository.
 
 The process for creating sentiment dictionaries comprises three major steps, each of them described in more detail in the sections below. Overall, we first need to generate a set of seed words which serves as a basis to automatically transfer sentiment to other words in the text corpus. For this expansion, we train word embeddings to capture the context of individual words and use them in a classification task to transfer sentiment of seed words to other words in similar contexts. Note that this process is suitable for a plethora of languages and is not limited to the 18<sup>th</sup> century languages. The following figure illustrates the whole dictionary creation pipeline:
 
 ![Overview of the Dictionary Creation Pipeline](miscellaneous/dictionary_creation_overview.png)
 
 %% Cell type:markdown id: tags:
 
 ### Sentiment Dictionaries 101
 
 Before we discuss the individual steps to create sentiment dictionaries, we want to give a short introduction of what sentiment dictionaries are and how they can be used for sentiment analysis.
 Assume we want to assess the sentiment on a sentence level and that we are given the following three sentences:
 
 **Sentence 1:** Today was a good day.<br>
 **Sentence 2:** I hate getting up early.<br>
 **Sentence 3:** This is both funny and sad at the same time.
 
 Further, we have a sentiment dictionary, which comprises a list of words, each associated with sentiment (e.g., positive or negative):
 
 | Word | Sentiment |
 | --- | --- |
 | good | positive |
 | bad | negative |
 | hate | negative |
 | funny | positive |
 | sad | negative |
 | happy | positive |
 
 We can assess the sentiment of each sentence by considering whether the words contained in the dictionary occur in them.
 For that, let us define the sentiment *s* of a sentence as follows:
 
-$$s = W_p - W_n$$
+![Sentiment Formula for the Introductory Example](miscellaneous/sentiment_formula_1.png)
 
 where $W_p$ is the number of positive words in a sentence and $W_n$ is the number of negative words in a sentence.
 Thus, the formula subtracts the number of words with a negative sentiment from the number of words with a positive sentiment.
 If the resulting value is negative, then we assume the sentiment of a sentence to be negative, whereas if the value is positive, we assume the sentiment of a sentence to be positive.
 This value is zero if the two numbers are equal or if there are no words of the dictionary in a sentence. In this case, we assume that the sentence has a neutral sentiment.
 
 For our three examples, this means that Sentence 1 has a positive sentiment, Sentence 2 a negative sentiment and Sentence 3 a neutral sentiment.
 To verify whether our assumption is true, we implement the example in Python. For that, we first create a list that contains the three example sentences from above:
 
 %% Cell type:code id: tags:
 
 ``` python
 example_sentences = [
     "Today was a good day.",
     "I hate getting up early.",
-    "This is both funny and sad at the same time."]
+    "This is both funny and sad at the same time."
+]
 ```
 
 %% Cell type:markdown id: tags:
 
 Further, we need to create a dictionary that maps our words in the dictionary to a sentiment:
 
 %% Cell type:code id: tags:
 
 ``` python
 sentiment_dictionary = {
     "good": "positive",
     "bad": "negative",
     "hate": "negative",
     "funny": "positive",
     "sad": "negative",
     "happy": "positive"
 }
 ```
 
 %% Cell type:markdown id: tags:
 
 We then define a function that takes one sentence as input and returns its computed sentiment following the formula and rules stated above:
 
 %% Cell type:code id: tags:
 
 ``` python
 def compute_sentiment(sentence):
     wpt = WordPunctTokenizer()
     words_list = wpt.tokenize(sentence)
     number_of_negative_words = 0
     number_of_positive_words = 0
     for word, sentiment in sentiment_dictionary.items():
         if sentiment == "negative":
             number_of_negative_words += words_list.count(word)
         elif sentiment == "positive":
             number_of_positive_words += words_list.count(word)
     sentiment_score = number_of_positive_words - number_of_negative_words
     if sentiment_score < 0:
         computed_sentiment = "negative"
     elif sentiment_score > 0:
         computed_sentiment = "positive"
     else:
         computed_sentiment = "neutral"
     return computed_sentiment
 ```
 
 %% Cell type:markdown id: tags:
 
 We then iterate through the list of sentences and print the sentiment for each of them:
 
 %% Cell type:code id: tags:
 
 ``` python
 for sentence in example_sentences:
     print("The sentiment for '{}' is {}.".format(sentence, compute_sentiment(sentence)))
 ```
 
 %%%% Output: stream
 
     The sentiment for 'Today was a good day.' is positive.
     The sentiment for 'I hate getting up early.' is negative.
     The sentiment for 'This is both funny and sad at the same time.' is neutral.
 
 %% Cell type:markdown id: tags:
 
 As we can now observe, the verification of our previous assumptions through Python confirms that they were all correct.
 
 The example above highlights the advantages of dictionary-based sentiment analysis approaches: first, it is straightforward to conduct (as demonstrated above) and second, the produced results are transparent and easily interpretable.
 
 %% Cell type:markdown id: tags:
 
 ### Step 1: Selecting Seed Words
 
 Our sentiment dictionary creation depends on seed words for which the sentiment is known. Based on these seed words, we can automatically transfer sentiment to other words, allowing us to circumvent a more tedious and time-consuming annotation process. This step comprises three parts: First, we extract seed words from the text corpus. Second, we manually annotate them. Third, we select annotated seed words based on the agreement of multiple annotators.
 
 #### Extracting Frequent Words
 At first, we extract the 3,000 most frequent words from the entire text corpus (without removing stop words or conducting lemmatization). The number of extracted seed words depends on the corpus size. We decided for a compromise between the number of words and the associated efforts to annotate them.
 In this case, these 3,000 most frequent words account for 3.9% of unique French words (76,035 in total), 2.5% of unique italian words (121,504 in total) and 3.6% of unique Spanish words (84,185 in total).
 Focusing on most frequent words allows us to achieve a good coverage as seed words that do not occur frequently in our texts are of no use in the subsequent classification task.
 The Jupyter Notebook for the extraction of seed words (see `code/dictionary_creation/1_seed_words/1_extraction.ipynb`) allows for additional settings, such as a maximum document frequency of words to extract.
 
 #### Annotating Frequent Words
 Once we extracted frequent words, we let three experts, who are familiar with the content and context of the French, Italian and Spanish Spectator periodicals, annotate the seed words.
 In particular, we instructed them to assign each of the extracted words to either of three sentiment classes: (i) positive, (ii) negative or (iii) neutral and to take into account the sociocultural circumstances of the 18<sup>th</sup> century.
 As a result, the annotators captured the sentiment of words with regard to their intended meaning.
 
 The provided Jupyter Notebook (see `code/dictionary_creation/1_seed_words/2_annotation.ipynb`) for the annotation of words includes a few simple code lines to generate *.csv* files which can then be opened and annotated in an arbitrary spreadsheet program (e.g., Microsoft Excel or LibreOffice Calc).
 Note that the annotated sentiment needs to be entered in the *sentiment* column of the generated file and, for the remaining Jupyter Notebooks to work without changes, the annotators must stick to the following three classes: *positive*, *negative* and *neutral*. For example, the annotations for the words *good*, *bad* and *house* could be:
 
 word | sentiment
 --- | ---
 good | positive
 bad	| negative
 house |	neutral
 
 However, other expressions of sentiment, such as additional classes or numerical values, may be used if the subsequent Jupyter Notebooks are adjusted accordingly.
 
 #### Selecting Seed Words
 
 As past research has indicated that sentiment is very subjective and involves disagreement between multiple individuals (Mozetič et al. 2016), we need to implement a selection procedure to settle on the final sentiment of frequent words.
 For that, we use a simple majority vote, in which we only keep words for which at least two annotators have equal annotations and in which we remove the remaining words otherwise.
 Regarding the number of annotators, we suggest employing as many of them as possible as it allows for better generalization.
 Naturally, there is a trade-off between the number of annotators you can find/afford (i.e., it is very time-consuming to annotate words, especially when you have to consider the sociocultural context) and the quality of resulting annotations.
 In our case, we went with three (which we consider the lowest limit) annotators, who have all worked with the data for several years and have an extensive knowledge about this period in time.
 
 The Jupyter Notebook (see `code/dictionary_creation/1_seed_words/3_selection.ipynb`) for the selection of seed words provides a ready-to-use implementation based on a majority vote. In the following table, we provide the number of positive, negative and neutral selected seed words:
 
 Language | # positive | # negative | # neutral
 --- | --- | --- | ---
 French | 803 | 381 | 1,738
 Italian | 1,811 | 244 | 838
 Spanish | 385 | 251 | 2,340
 
 %% Cell type:markdown id: tags:
 
 ### Step 2: Creating Word Embeddings
 
 Computers have hard times working with text or words.
 To counteract this problem, we need to transform text or words into numerical forms.
 One way to achieve this are so-called word embeddings, which represent words by vectors.
 Existing research discerns two types of word embeddings: (i) frequency-based word embeddings, such as count vectors or TF-IDF vectors, as well as prediction-based word embeddings, such as word2vec (Mikolov et al. 2013).
 
 Before describing our utilized method, we want to demonstrate principles of word embeddings in the following example.
 For that, consider the following three sentences contained in a list:
 
 %% Cell type:code id: tags:
 
 ``` python
 example_sentences = [
     "Word embeddings are fun.",
     "It is fun to learn new things.",
     "Teaching word embeddings is also fun."
 ]
 ```
 
 %% Cell type:markdown id: tags:
 
 We can use the `CountVectorizer` from the `scikit-learn` package to create a count matrix and store that in a pandas `DataFrame` for easier interpretation:
 
 %% Cell type:code id: tags:
 
 ``` python
 vectorizer = CountVectorizer()
 count_matrix = vectorizer.fit_transform(example_sentences)
 count_vectors_df = pandas.DataFrame(count_matrix.todense(), columns=vectorizer.get_feature_names())
 display(count_vectors_df)
 ```
 
 %%%% Output: display_data
 
 
 %% Cell type:markdown id: tags:
 
 As we can now observe, this produces a table in which each row represents one of the three sentences and each column represents a distinct word occurring in either of the three sentences.
 Each value in the cells of the table equals 1 if the respective word occurs in the respective sentence or 0 otherwise.
 We can then find the vector representation of a word by considering the values in its column.
 For example, the vector of the word *embeddings* is `[1, 0, 1]` and of the word *fun* is `[1, 1, 1]`.
 Thus, a word is represented by the set of sentences/documents in which it occurs.
 
 Word embeddings also capture the context of a word in a document, including the semantic similarity as well as the relations with other words.
 As such, vectors of words that are frequently used together in texts are also very close to each other in the resulting vector space.
 Contrary, vectors of words that are never or only minimally used in a similar context should be very distant from each other.
 This suits perfectly for our dictionary creation process and based on the vector representation of words, we can automatically transfer sentiment from our seed words to other words.
 
 %% Cell type:markdown id: tags:
 
 #### Word2Vec
 
 For our dictionary creation pipeline we rely on word2vec (Mikolov et al. 2013), a state-of-the-art method to compute word embeddings.
 Word2vec relies on a two-layer neural network to train word vectors that capture the linguistic contexts of words and comprises either one of two different model architectures: continuous bag-of-words (CBOW) or skip-gram.
 The former predicts a word from a given context whereas the latter predicts the context from a given word.
 Both have their advantages and disadvantages regarding the size of the underlying text corpus, which is why we consider both of them in our tool chain.
 
-Before talking about the specifics of our approach, we want to demonstrate the benefits of word2vec. In the following example, we use Gensim's word2vec implementation to train word embeddings of the publicly available *text8* dataset (you have already downloaded it in the *Introduction* section of this Notebook).
-
-We can train the model with one line of code (note that this can take several minutes to complete):
+Before talking about the specifics of our approach, we want to demonstrate the benefits of word2vec. For the following example, we used Gensim's word2vec implementation to train word embeddings of the publicly available *text8* dataset. We can load the pretrained word2vec model with the following line of code:
 
 %% Cell type:code id: tags:
 
 ``` python
-word2vec_model = Word2Vec(word2vec_example_corpus)
+word2vec_model = Word2Vec.load("data/processed_data/word2vec_models/example.p")
 ```
 
 %% Cell type:markdown id: tags:
 
-With the default setup of the `word2vec` method, we train vectors with a dimension of 100. Thus, instead of the three numbers in a vector from the count vector example above, we now have 100 numbers (i.e., a vector of length 100).
+As we used the default parameters for word2vec as implemented in Gensim, we trained vectors with a dimension of 100. Thus, instead of the three numbers in a vector from the count vector example above, we now have 100 numbers (i.e., a vector of length 100).
 Moreover, these numbers are now real-valued instead of integer and their interpretation is less self-evident.
 We can inspect the resulting vector of a word, for example *car*, with:
 
 %% Cell type:code id: tags:
 
 ``` python
 print(word2vec_model.wv["car"])
 ```
 
 %%%% Output: stream
 
-    [-0.96366096 -1.3742831   0.73106915  1.2464461   0.19334741 -0.858718
-     -0.01184064 -0.24652933 -1.0748054  -0.5054727   1.1855398  -0.62031776
-      0.39737985  1.8011881  -2.595472   -1.9477972   0.44193438 -1.2095671
-     -0.03679457  0.22283824  0.8520565   0.19460759  0.601061   -0.25661194
-      0.5227143  -1.2684288  -0.6947603   0.71117973 -0.83271295  1.3840522
-      2.6297543   2.1552653   0.46458372 -0.15175714 -1.7563695  -0.18980268
-     -0.19808206 -2.296005   -0.4825583   0.84871304  0.7676269  -0.23888186
-      1.5052361   1.7347597   2.9247804  -0.60031617 -2.162292    0.19464816
-      0.38104555 -0.25405452  0.56672496  0.18307838  1.9986428  -3.067654
-      1.2176334   1.1274312   0.52531594  0.21777926  0.16100219 -0.06693241
-     -0.9263279   0.34482655 -0.7890902  -0.06024634 -0.6747798  -0.88505363
-     -0.8940445   0.63983166 -0.28610742 -3.1221943   0.9004476   1.3235196
-      0.33159682  1.4678319   0.07791691  1.7263894  -1.1614616   1.1387984
-     -1.2820066  -1.8504483  -0.41011232 -1.8067706   1.8940349   1.5587422
-     -1.9671468  -0.20638618  1.795837   -0.37610653  1.1748948   0.65870816
-     -1.9154986  -2.549661   -3.388793   -0.27740353  0.83503336 -2.0548694
-      1.2873101  -0.23276174  3.1180558   2.5557537 ]
+    [-0.12308194 -0.39095813  1.000928   -0.04769582  0.9710199  -1.3676833
+     -1.4404075  -0.7423445   1.6969757  -1.1585793   0.64239687  0.6409116
+      1.4341261   0.4111035  -2.4854403  -0.7219625   1.540313    0.42790467
+     -0.44106185 -1.114401    1.3602705   0.8318557   2.0098808   0.7983357
+     -1.5087671  -0.8375068  -0.61658716  1.2119923  -0.6702468  -0.3222445
+      0.9415244   2.6550481  -0.99794585  0.04601024 -1.6316731  -1.439617
+     -1.431928   -2.4456704  -0.71318716  0.86487716  2.2365756  -0.89588803
+     -0.7087643   0.9257705   1.712533    0.7194995  -2.4665103  -1.3497332
+      2.2958574  -0.54635614  0.9186488   0.51365685  0.09351666 -1.0833061
+     -0.00810259  2.8242166   0.1252522  -1.207868    0.10782211 -0.34977445
+     -0.30000007  0.33047387 -0.12232512 -0.52950805 -2.4587536  -0.37481222
+     -2.2148058   0.14348628 -0.79030484 -2.5900028   2.7875724  -0.7795173
+      0.6641297   2.6237233   1.7713573   1.7022327  -0.04617653  1.2087046
+     -1.4730823   0.74134797 -0.26776415  0.22373354  0.71002257  1.5748668
+     -1.778043    0.48367617  1.0869575  -0.6362949   0.63211554  0.5351157
+     -1.8014896   0.39312994 -2.118675    0.83928734 -0.3225636  -2.1843622
+     -0.557146   -1.6596688   1.2372373   3.977601  ]
 
 %% Cell type:markdown id: tags:
 
 We can find words similar to *car* by considering the cosine similarity between the vector of *car* and all other vectors. The higher the similarity, the more similar are the words. Gensim provides an easy way to find most similar words based on cosine similarity:
 
 %% Cell type:code id: tags:
 
 ``` python
 word2vec_model.wv.most_similar("car", topn=20)
 ```
 
 %%%% Output: execute_result
 
-    [('driver', 0.7858742475509644),
-     ('cars', 0.7570940852165222),
-     ('motorcycle', 0.7254790663719177),
-     ('taxi', 0.7133187055587769),
-     ('truck', 0.7059160470962524),
-     ('tire', 0.6728494763374329),
-     ('racing', 0.6664857268333435),
-     ('cab', 0.6571638584136963),
-     ('automobile', 0.655803918838501),
-     ('glider', 0.6467955708503723),
-     ('passenger', 0.6462221741676331),
-     ('vehicle', 0.6456612944602966),
-     ('motor', 0.6449832320213318),
-     ('automobiles', 0.6323708891868591),
-     ('mercedes', 0.6311836242675781),
-     ('diesel', 0.6301203370094299),
-     ('honda', 0.6140277981758118),
-     ('powered', 0.613706111907959),
-     ('pilot', 0.6132946610450745),
-     ('stock', 0.6110790967941284)]
+    [('driver', 0.7839363217353821),
+     ('taxi', 0.7524467706680298),
+     ('cars', 0.725511908531189),
+     ('motorcycle', 0.7036831378936768),
+     ('vehicle', 0.698715090751648),
+     ('truck', 0.6913774609565735),
+     ('passenger', 0.661078155040741),
+     ('automobile', 0.6501474380493164),
+     ('audi', 0.6245964169502258),
+     ('glider', 0.6229903101921082),
+     ('tire', 0.6213281154632568),
+     ('cab', 0.6198135018348694),
+     ('engine', 0.6183426380157471),
+     ('volkswagen', 0.6164752840995789),
+     ('engined', 0.6096624732017517),
+     ('airplane', 0.6076435446739197),
+     ('bmw', 0.6070380210876465),
+     ('elevator', 0.6061339974403381),
+     ('racing', 0.6031301617622375),
+     ('stock', 0.6030023097991943)]
 
 %% Cell type:markdown id: tags:
 
 Another advantage of word2vec compared to count vectors is that it can capture various concepts and analogies.
-Perhaps the most famous example in that regard is as follows: If you subtract the vector of the word *man* from the vector of the word *king* and add the vector of the word *woman* it should result in a vector very close to that of the word *queen*. We can evaluate whether this is the case with our trained model through Gensim very easily:
+Perhaps the most famous example in that regard is as follows: If you subtract the vector of the word *man* from the vector of the word *king* and add the vector of the word *woman* it should result in a vector very close to that of the word *queen*. We can evaluate whether this is the case with our pretrained model through Gensim very easily:
 
 %% Cell type:code id: tags:
 
 ``` python
 word2vec_model.wv.most_similar(positive=["woman", "king"], negative=["man"], topn=1)
 ```
 
 %%%% Output: execute_result
 
-    [('prince', 0.6386325359344482)]
+    [('queen', 0.6670934557914734)]
 
 %% Cell type:markdown id: tags:
 
 We observe that, indeed, the trained word embedding correctly reflects this analogy.
 Can you think of any other concepts or analogies to test? Feel free to try it with other word vectors.
 
 %% Cell type:markdown id: tags:
 
 #### Training the Models
 
 Before we start training the actual word2vec models for the Spectator periodicals in the respective languages, we need to preprocess our texts.
 The amount of required preprocessing for word2vec is very minimal, as we only need to remove stop words and extract individual sentences.
 The latter is important because individual sentences are the required input form for the word2vec implementation of Gensim.
 
 Since word2vec has many hyperparameters (that all have an impact on the resulting word embeddings), we need to tune them to achieve the best possible performance.
 One way to optimize hyperparameters is to conduct a *grid search*.
 For this purpose, we define a set of possible hyperparameters and train one individual model for each possible hyperparameter combination.
 We then evaluate each model and select the one that yielded the best performance.
 The Jupyter Notebook (see `code/dictionary_creation/2_word_embeddings/1_grid_search.ipynb`) contains a selection of possible hyperparameters, but further adjustments may be necessary.
 For that, we refer to the [documentation](https://radimrehurek.com/gensim/models/word2vec.html#gensim.models.word2vec.Word2Vec) (Řehůřek 2009-2021) of the word2vec implementation of Gensim.
 
 All models trained this way are stored for later use and, depending on your text corpus and the number of hyperparameter combinations, the file size of stored models can take hundreds of gigabytes.
 
 #### Evaluating the Models
 
 Once we trained one model for each hyperparameter combination, we need to evaluate which of these combinations achieved the best performance.
 For this evaluation, we rely on lists of manually annotated word pairs, in which every word pair was assigned to a relation score.
 In our case, this relation score ranges from 0 to 10, where 0 represents no similarity and 10 represents absolute similarity.
 For example, when we consider the word pairs *old & new*, *easy & hard*, *beautiful & wonderful* as well as *rare & scarce*, the respective scores could be:
 
 word pair | relation score
 --- | ---
 old & new | 0
 easy & hard	| 1.23
 beautiful & wonderful |	7.15
 rare & scarce | 9.89
 
 Typically, such word pair lists are manually annotated, which is again a very time-consuming and tedious process and requires multiple annotators. In our case, we adapt previously existing lists for French, Italian and Spanish (Freitas et al. 2016; [GitHub Repository](https://github.com/siabar/Multilingual_Wordpairs)).
 More precisely, we filter all words that are not existing in our historic Spectator periodicals, extend lists with spelling variations of the 18<sup>th</sup> century as well as check whether relation scores are meaningful and also applicable to the languages of the 18<sup>th</sup> century.
 
 Using the adapted lists, we can compute Pearson correlation coefficients between scores of word pairs and similarities of respective word vectors from the trained models in our dedicated Jupyter Notebook (see `code/dictionary_creation/2_word_embeddings/2_evaluation.ipynb`).
 We then select the model for which the correlation coefficients are the highest and report the following coefficients for the respective languages:
 
 Language | Pearson Rho
 --- | ---
 French | 0.402
 Italian | 0.157
 Spanish | 0.310
 
 We provide the selected models in the data folder of this repository.
 To use them for your own projects, download them and load the pickled Gensim word2vec model in Python:
 
 ```python
 import pickle
 from gensim.models import Word2Vec
 
 path_to_model = "" # set the path to where you saved the model (e.g., path_to_model="french.p")
 
 with open(path_to_model, "rb") as handle:
     model = pickle.load(handle)
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Step 3: Transferring Sentiment
 
 In the third and final step of the dictionary creation pipeline, we use the generated word embeddings to transfer the sentiment from our seed words to other words that appear in a similar context of seed words.
 For that, we use a *k*-nearest neighbors (KNN) classifier (Fix and Hodges 1951) that considers the distances between word vectors.
 Remember that the trained word embeddings keep words that appear frequently in a similar context close together and words that are not related very distant from each other in the vector space.
 As such, this straightforward and interpretable classification method is perfectly suited for our context-based transfer of sentiment.
 
 #### Classifying Words
 
 The *k*-nearest neighbors classifier is based on distances between vectors in a multidimensional feature space (in our case the vectors from the trained word embeddings).
 It classifies an unlabeled instance based on the *k* nearest labeled neighbors of that instance, where *k* can take an arbitrary value.
 
 To demonstrate the functioning of the KNN classifier, we implement a two-dimensional example in Python:
 
 %% Cell type:code id: tags:
 
 ``` python
 example_X_data = [
     [2, 2],
     [3, 5],
     [4, 8],
     [5, 2],
     [6, 9],
     [2, 6],
     [8, 7]
 ]
 
 example_X_labels = [
     "blue",
     "red",
     "red",
     "blue",
     "red",
     "red",
     "blue"
 ]
 
 example_y_data = [
     [3, 3]
 ]
 
 fig, ax = plt.subplots(figsize=(5, 5))
 ax.scatter(*zip(*example_X_data), c=example_X_labels)
 ax.scatter(*zip(*example_y_data), c="black", marker="x")
 ax.set_xlim(0, 10)
 ax.set_ylim(0, 10)
 plt.show()
 plt.close()
 ```
 
 %%%% Output: display_data
 
     ![](data:image/png;base64,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)
 
 %% Cell type:markdown id: tags:
 
 In this example, we have two different classes (or labels): the *blue* points and the *red* points.
 We have one unlabeled instance, in this case a black cross, which we want to assign to either of the two classes.
 The resulting class for the unlabeled instance depends on how we set *k*.
 Note that for a binary classification task (two classes), only odd numbers for *k* make sense as it could result in ties otherwise.
 
 Now we can train the classifier based on the labeled instances using the `KNeighborsClassifier` method from `scikit-learn`, find the nearest neighbors of our unlabeled instance and assign it to the majority class of these neighbors. For this example, we set *k* to 3:
 
 %% Cell type:code id: tags:
 
 ``` python
 k = 3
 neigh = KNeighborsClassifier(n_neighbors=k)
 neigh.fit(example_X_data, example_X_labels)
 
 nearest_neighbors = neigh.kneighbors(example_y_data)[1][0]
 
 fig, ax = plt.subplots(figsize=(5, 5))
 ax.scatter(*zip(*example_X_data), c=example_X_labels)
 ax.scatter(*zip(*example_y_data), c="black", marker="x")
 for n_i in nearest_neighbors:
     ax.plot([example_y_data[0][0], example_X_data[n_i][0]], [example_y_data[0][1], example_X_data[n_i][1]], 'gray', linestyle=':', marker='')
 ax.set_xlim(0, 10)
 ax.set_ylim(0, 10)
 plt.show()
 plt.close()
 Markdown("The unlabeled instance is assigned to the *{}* class.".format(neigh.predict(example_y_data)[0]))
 ```
 
 %%%% Output: display_data
 
     ![](data:image/png;base64,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)
 
 %%%% Output: execute_result
 
     The unlabeled instance is assigned to the *blue* class.
     <IPython.core.display.Markdown object>
 
 %% Cell type:markdown id: tags:
 
 For *k* = 3, the algorithm considers the three nearest neighbors (indicated by the dashed gray lines)  which include one instance of the *red* class and two instances of the *blue* class.
 As the majority of neighbors are labeled *blue*, it assigns our unlabeled instance to the *blue* class.
 But what about other values of *k*? Feel free to adjust *k* in the above code block and observe the different outcomes.