{"id":3344,"date":"2016-09-28T15:27:28","date_gmt":"2016-09-28T19:27:28","guid":{"rendered":"http:\/\/fgiasson.com\/blog\/?p=3344"},"modified":"2016-11-17T13:42:14","modified_gmt":"2016-11-17T18:42:14","slug":"using-cognonto-to-generate-domain-specific-word2vec-models","status":"publish","type":"post","link":"https:\/\/fgiasson.com\/blog\/index.php\/2016\/09\/28\/using-cognonto-to-generate-domain-specific-word2vec-models\/","title":{"rendered":"Using Cognonto to Generate Domain Specific word2vec Models"},"content":{"rendered":"

word2vec<\/a> is a two layer artificial neural network<\/a> used to process text to learn relationships between words within a text corpus to create a model<\/a> of all the relationships between the words of that corpus. The text corpus that a word2vec process uses to learn the relationships between words is called the training corpus<\/a>.<\/p>\n

In this article I will show you how Cognonto<\/a>‘s knowledge base can be used to automatically create highly accurate domain specific training corpuses that can be used by word2vec to generate word relationship models. However you have to understand that what is being discussed here is not only applicable to word2vec, but to any method that uses corpuses of text for training. For example, in another article, I will show how this can be done with another algorithm called ESA (Explicit Semantic Analysis).<\/p>\n

It is said about word2vec that “given enough data, usage and contexts, word2vec can make highly accurate guesses about a word\u00e2\u20ac\u2122s meaning based on past appearances.” What I will show in this article is how to determine the context and we will see how this impacts the results.<\/p>\n

<\/p>\n

\n

Training Corpus<\/h2>\n
\n

A training corpus is really just a set of text used to train unsupervised machine learning algorithms. Any kind of text can be used by word2vec. The only thing it does is to learn the relationships between the words that exist in the text. However, not all training corpuses are equal. Training corpuses are often dirty, biaised and ambiguous. Depending on the task at hand, it may be exactly what is required, but more often than not, their errors need to be fixed. Cognonto has the advantage of starting with clean text.<\/p>\n

When we want to create a new training corpus, the first step is to find a source of text that could work to create that corpus. The second step is to select the text we want to add to it. The third step is to pre-process that corpus of text to perform different operations on the text, such as: removing HTML elements; removing punctuation; normalizing text; detecting named entities; etc. The final step is to train word2vec to generate the model.<\/p>\n

word2vec is somewhat dumb. It only learns what exists in the training corpus. It does not do anything other than “reading” the text and analyzing the relationships between the words (which are really just group of characters separated by spaces). The word2vec process is highly subject to the Garbage In, Garbage Out<\/a> principle, which means that if the training set is dirty, biaised and ambiguous, then the learned relationship will end-up being of little or no value.<\/p>\n<\/div>\n<\/div>\n

\n

Domain-specific Training Corpus<\/h2>\n
\n

A domain-specific training corpus is a specialized training corpus where its text is related to a specific domain. Examples of domains are music, mathematics, cars, healthcare, etc. In contrast, a general training corpus is a corpus of text that may contain text that discusses totally different domains. By creating a corpus of text that covers a specific domain of interest, we limit the usage of words (that is, their co-occurrences) to texts that are meaningful to that domain.<\/p>\n

As we will see in this article, a domain-specific training corpus can be quite useful, and much more powerful, than general ones, if the task at hand is in relation to a specific domain of expertise. The major problem with domain-specific training corpuses is that they are really costly to create. We not only have to find the source of data to use, but we also have to select each document that we want to include in the training corpus. This can work if we want a corpus with 100 or 200 documents, but what if you want a training corpus of 100,000 or 200,000 documents? Then it becomes a problem.<\/p>\n

It is the kind of problem that Cognonto helps to resolve. Cognonto and KBpedia, its knowledge base, is a set of ~39,000 reference concepts that have ~138,000 links to schema of external data sources such as Wikipedia, Wikidata and USPTO. It is that structure and these links to external data sources that we use to create domain-specific training corpuses on the fly<\/i>. We leverage the reference concept structure to select all of the concepts that should be part of the domain that is being defined. Then we use Cognonto’s inference capabilities to infer all the other hundred or thousands of concepts that define the full scope of the domain. Then we analyze the hundreds or thousands of concepts we selected that way to get all of the links to external data sources. Finally we use these references to create the training corpus. All of this is done automatically once the initial few concepts that define my domain got selected. The workflow looks like:<\/p>\n

\n

\"cognonto-workflow\"<\/a><\/p>\n<\/div>\n<\/div>\n<\/div>\n

\n

The Process<\/h2>\n
\n

To show you how this process works, I will create a domain-specific training set about musicians using Cognonto. Then I will use the Google News word2vec model created by Google and that has about 100 billion words. The Google model contains 300-dimensional vectors for 3 million words and phrases. I will use the Google News model as the general model to compare the results\/performance between a domain specific and a general model.<\/p>\n<\/div>\n

\n

Determining the Domain<\/h3>\n
\n

The first step is to define the scope of the domain we want to create. For this article, I want a domain that is somewhat constrained to create a training corpus that is not too large for demo purposes. The domain I have chosen is musicians<\/code>. This domain is related to people and bands that play music. It is also related to musical genres, instruments, music industry, etc.<\/p>\n

To create my domain, I select a single KBpedia reference concept: Musician<\/a>. If I wanted to broaden the scope of the domain, I could have included other concepts such as: Music<\/a>, Musical Group<\/a>, Musical Instrument<\/a>, etc.<\/p>\n<\/div>\n<\/div>\n

\n

Aggregating the Domain-specific Training Corpus<\/h3>\n
\n

Once we have determined the scope of the domain, the next step is to query the KBpedia knowledge base to aggregate all of the text that will belong to that training corpus. The end result of this operation is to create a training corpus with text that is only related to the scope of the domain we defined.<\/p>\n

\n
(<\/span>defn<\/span> create-domain-specific-training-set<\/span>\n  [<\/span>target-kbpedia-class corpus-file]<\/span>\n  (<\/span>let<\/span> [<\/span>step 1000\n        entities-dataset \"http:\/\/kbpedia.org\/knowledge-base\/\"<\/span>\n        kbpedia-dataset \"http:\/\/kbpedia.org\/kko\/\"<\/span>\n        nb-entities (<\/span>get-nb-entities-for-class-ws target-kbpedia-class entities-dataset kbpedia-dataset)<\/span>]<\/span>\n    (<\/span>loop<\/span> [<\/span>nb 0\n           nb-processed 1]<\/span>\n      (<\/span>when<\/span> (<\/span>< nb nb-entities)<\/span>\n        (<\/span>doseq<\/span> [<\/span>entity (<\/span>get-entities-slice target-kbpedia-class entities-dataset kbpedia-dataset :limit<\/span> step :offset<\/span> @nb-processed)<\/span>]<\/span>          \n          (<\/span>spit corpus-file (<\/span>str (<\/span>get-entity-content entity)<\/span> \"\\n\"<\/span>)<\/span> :append<\/span> true<\/span>)<\/span>\n          (<\/span>println (<\/span>str nb-processed \"\/\"<\/span> nb-entities)<\/span>)<\/span>)<\/span>\n        (<\/span>recur<\/span> (<\/span>+ nb step)<\/span>\n               (<\/span>inc nb-processed)<\/span>)<\/span>)<\/span>)<\/span>)<\/span>)<\/span>\n\n(<\/span>create-domain-specific-training-set \"http:\/\/kbpedia.org\/kko\/rc\/Musician\"<\/span> \"resources\/musicians-corpus.txt\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
What this code does is to query the KBpedia knowledge base to get all the named entities that are linked to it, for the scope of the domain we defined. Then the text related to each entity is appended to a text file where each line is the text of a single entity.<\/p>\n
Given the scope of the current demo, the musicians training corpus is composed of 47,263<\/code> documents. This is the crux of the demo. With a simple function, we are able to aggregate 47,263 text documents highly related to a conceptual domain we defined on the fly. All of the hard work has been delegated to the knowledge base and its conceptual structure (in fact, this simple function leverages 8 years of hard work<\/a>).<\/p>\n<\/div>\n<\/div>\n
\n
Normalizing Text<\/h3>\n
\n
The next step is a natural step related to any NLP<\/a> pipeline. Before learning from the training corpus, we should clean and normalize the text of its raw form.<\/p>\n
\n
(<\/span>defn<\/span> normalize-proper-name<\/span>\n  [<\/span>name]<\/span>\n  (<\/span>-><\/span> name\n      (<\/span>string<\/span>\/<\/span>replace #\" \"<\/span> \"_\"<\/span>)<\/span>      \n      (<\/span>string<\/span>\/<\/span>lower-case)<\/span>)<\/span>)<\/span>\n\n(<\/span>defn<\/span> pre-process-line<\/span>\n  [<\/span>line]<\/span>  \n  (<\/span>-><\/span> (<\/span>let<\/span> [<\/span>line (<\/span>-><\/span> line\n                     ;; <\/span>1. remove all underscores<\/span>\n                     (<\/span>string<\/span>\/<\/span>replace \"_\"<\/span> \" \"<\/span>)<\/span>)<\/span>]<\/span>\n        ;; <\/span>2. detect named entities and change them with their underscore form, like: Fred Giasson -> fred_giasson<\/span>\n        (<\/span>loop<\/span> [<\/span>entities (<\/span>into []<\/span> (<\/span>re-seq #\"[\\p{Lu}]<\/span>(<\/span>[\\p{Ll}]+<\/span>|<\/span>\\.<\/span>)(?:<\/span>\\s+[\\p{Lu}]<\/span>(<\/span>[\\p{Ll}]+<\/span>|<\/span>\\.<\/span>))<\/span>*<\/span>(?:<\/span>\\s+[\\p{Ll}][\\p{Ll}\\-]{1,3}<\/span>)<\/span>{0,1}\\s+[\\p{Lu}]<\/span>(<\/span>[\\p{Ll}]+<\/span>|<\/span>\\.<\/span>)<\/span>\"<\/span> line)<\/span>)<\/span>\n               line line]<\/span>\n          (<\/span>if<\/span> (<\/span>empty? entities)<\/span>\n            line\n            (<\/span>let<\/span> [<\/span>entity (<\/span>first (<\/span>first entities)<\/span>)<\/span>]<\/span>\n              (<\/span>recur<\/span> (<\/span>rest entities)<\/span>                     \n                     (<\/span>string<\/span>\/<\/span>replace line entity (<\/span>normalize-proper-name entity)<\/span>)<\/span>)<\/span>)<\/span>)<\/span>)<\/span>)<\/span>\n      (<\/span>string<\/span>\/<\/span>replace (<\/span>re-pattern stop-list)<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>4. remove everything between brackets like: [1] [edit] [show]<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\[.*\\]\"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>5. punctuation characters except the dot and the single quote, replace by nothing: (),[]-={}\/\\~!?%$@&*+:;<><\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"[\\^\\<\/span>(<\/span>\\<\/span>)<\/span>\\,\\[\\]\\=\\{\\}\\\/\\\\\\~\\!\\?\\%\\$\\@\\&\\*\\+:\\;\\<\\>\\\"\\p{Pd}]\"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>6. remove all numbers<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"[0-9]\"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>7. remove all words with 2 characters or less<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\b[\\p{L}]{0,2}\\b\"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>10. normalize spaces<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\s{2,}\"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>11. normalize dots with spaces<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\s\\.\"<\/span> \".\"<\/span>)<\/span>\n      ;; <\/span>12. normalize dots<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\.{1,}\"<\/span> \".\"<\/span>)<\/span>\n      ;; <\/span>13. normalize underscores<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\_{1,}\"<\/span> \"_\"<\/span>)<\/span>\n      ;; <\/span>14. remove standalone single quotes<\/span>\n      (<\/span>string<\/span>\/<\/span>replace \" ' \"<\/span> \" \"<\/span>)<\/span>\n      ;; <\/span>15. re-normalize spaces<\/span>\n      (<\/span>string<\/span>\/<\/span>replace #\"\\s{2,}\"<\/span> \" \"<\/span>)<\/span>        \n      ;; <\/span>16. put everything lowercase<\/span>\n      (<\/span>string<\/span>\/<\/span>lower-case)<\/span>\n\n      (<\/span>str \"\\n\"<\/span>)<\/span>)<\/span>)<\/span>\n\n(<\/span>defn<\/span> pre-process-corpus<\/span>\n  [<\/span>in-file out-file]<\/span>\n  (<\/span>spit out-file \"\"<\/span> :append<\/span> true<\/span>)<\/span>\n  (<\/span>with-open<\/span> [<\/span>file (<\/span>clojure.java.io<\/span>\/<\/span>reader in-file)<\/span>]<\/span>\n    (<\/span>doseq<\/span> [<\/span>line (<\/span>line-seq file)<\/span>]<\/span>\n      (<\/span>spit out-file (<\/span>pre-process-line line)<\/span> :append<\/span> true<\/span>)<\/span>)<\/span>)<\/span>)<\/span>\n\n(<\/span>pre-process-corpus \"resources\/musicians-corpus.txt\"<\/span> \"resources\/musicians-corpus.clean.txt\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
We remove all of the characters that may cause issues to the tokenizer used by the word2vec implementation. We also remove unnecessary words and other words that appear too often or that add nothing to the model we want to generate (like the listing of days and months). We also drop all numbers.<\/p>\n<\/div>\n<\/div>\n
\n
Training word2vec<\/h3>\n
\n
The last step is to train word2vec on our clean domain-specific training corpus to generate the model we will use. For this demo, I will use the DL4J<\/a> (Deep Learning for Java) library that is a Java implementation of the word2vec algorithm. Training word2vec is as simple as using the DL4J API like this:<\/p>\n
\n
(<\/span>defn<\/span> train<\/span>\n  [<\/span>training-set-file model-file]<\/span>\n  (<\/span>let<\/span> [<\/span>sentence-iterator (<\/span>new<\/span> LineSentenceIterator<\/span> (<\/span>clojure.java.io<\/span>\/<\/span>file training-set-file)<\/span>)<\/span>\n        tokenizer (<\/span>new<\/span> DefaultTokenizerFactory<\/span>)<\/span>\n        vec (<\/span>..<\/span> (<\/span>new<\/span> Word2Vec$Builder<\/span>)<\/span>\n                (<\/span>minWordFrequency<\/span> 1)<\/span>\n                (<\/span>windowSize<\/span> 5)<\/span>\n                (<\/span>layerSize<\/span> 100)<\/span>\n                (<\/span>iterate sentence-iterator)<\/span>\n                (<\/span>tokenizerFactory<\/span> tokenizer)<\/span>\n                build)<\/span>]<\/span>\n    (<\/span>.fit<\/span> vec)<\/span>\n    (<\/span>SerializationUtils<\/span>\/<\/span>saveObject<\/span> vec (<\/span>io<\/span>\/<\/span>file model-file)<\/span>)<\/span>\n    vec)<\/span>)<\/span>\n\n(<\/span>def<\/span> musicians-model<\/span> (<\/span>train \"resources\/musicians-corpus.clean.txt\"<\/span> \"resources\/musicians-corpus.model\"<\/span>)<\/span>)<\/span>\n<\/pre>\n<\/div>\n
What is important to notice here is the number of parameters that can be defined to train word2vec on a corpus. In fact, that algorithm can be sensitive to parametrization.<\/p>\n<\/div>\n<\/div>\n
\n
Importing the General Model<\/h3>\n
\n
The goal of this demo is to demonstrate the difference between a domain-specific model and a general model. Remember that the general model we chose was the Google News model that is composed of billion of words, but which is highly general. DL4J can import that model without having to generate it ourselves (in fact, only the model is distributed by Google, not the training corpus):<\/p>\n
\n
(<\/span>defn<\/span> import-google-news-model<\/span>\n  []<\/span>\n  (<\/span>org.deeplearning4j.models.embeddings.loader.WordVectorSerializer<\/span>\/<\/span>loadGoogleModel<\/span> (<\/span>clojure.java.io<\/span>\/<\/span>file \"GoogleNews-vectors-negative300.bin.gz\"<\/span>)<\/span> true<\/span>)<\/span>)<\/span>\n\n(<\/span>def<\/span> google-news-model<\/span> (<\/span>import-google-news-model)<\/span>)<\/span>\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
Playing With Models<\/h2>\n
\n
Now that we have a domain-specific model related to musicians<\/code> and a general model related to news processed by Google, let’s start playing with both to see how they perform on different tasks. In the following examples, we will always compare the domain-specific training corpus with the general one.<\/p>\n<\/div>\n
\n
Ambiguous Words<\/h3>\n
\n
A characteristic of words is that their surface form can be ambiguous; they can have multiple meanings. An ambiguous word can co-occur with multiple other words that may not have any shared meaning. But all of this depends on the context. If we are in a general context, then this situation will happen more often than we think and will impact the similarity score of these ambiguous terms. However, as we will see, this phenomenum is greatly diminished when we use domain-specific models.<\/p>\n<\/div>\n
\n
Similarity Between Piano, Organ and Violin<\/h4>\n
\n
What we want to check is the relationship between 3 different music instruments: piano<\/code>, organ<\/code> and violin<\/code>. We want to check the relationship between each of them.<\/p>\n
\n
(<\/span>.similarity<\/span> musicians-model \"piano\"<\/span> \"violin\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.8422856330871582\n<\/pre>\n
\n
(<\/span>.similarity<\/span> musicians-model \"piano\"<\/span> \"organ\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.8573281764984131\n<\/pre>\n
As we can see, both tuples have a high likelihood of co-occurrence. This suggests that these terms of each tuple are probably highly related. In this case, it is probably because violins are often played along with a piano. And, it is probably that an organ looks like a piano (at least it has a keyboard).<\/p>\n
Now let’s take a look at what the general model has to say about that:<\/p>\n
\n
(<\/span>.similarity<\/span> google-news-model \"piano\"<\/span> \"violin\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.8228187561035156\n<\/pre>\n
\n
(<\/span>.similarity<\/span> google-news-model \"piano\"<\/span> \"organ\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.46168726682662964\n<\/pre>\n
The surprising fact here is the apparent dissimilarity between piano<\/code> and organ<\/code> compared with the results we got with the musicians domain-specific model. If we think a bit about this use case, we will probably conclude that these results makes sense. In fact, organ<\/code> is an ambiguous word in a general context. An organ can be a musical instrument, but it can also be a part of an anatomy. This means that the word organ<\/code> will co-occur beside piano<\/code>, but also all kind of other words related to human and animal biology. This is why they are less similar in the general model than in the domain one, because it is an ambiguous word in a general context.<\/p>\n<\/div>\n<\/div>\n
\n
Similarity Between Album and Track<\/h4>\n
\n
Now let’s see another similarity example between two other words album<\/code> and track<\/code> where track<\/code> is an ambiguous word depending on the context.<\/p>\n
\n
(<\/span>.similarity<\/span> musicians-model \"album\"<\/span> \"track\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.7943775653839111\n<\/pre>\n
\n
(<\/span>.similarity<\/span> google-news-model \"album\"<\/span> \"track\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.18461623787879944\n<\/pre>\n
As expected, because track<\/code> is ambiguous, there is a big difference in terms of co-occurence probabilities depending on the context (domain-specific or general).<\/p>\n<\/div>\n<\/div>\n
\n
Similarity Between Pianist and Violinist<\/h4>\n
\n
However, are domain-specific and general differences always the case? Let’s take a look at two words that are domain specific and unambiguous: pianist<\/code> and violinist<\/code>.<\/p>\n
\n
(<\/span>.similarity<\/span> musicians-model \"pianist\"<\/span> \"violinist\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.8430571556091309\n<\/pre>\n
\n
(<\/span>.similarity<\/span> google-news-model \"pianist\"<\/span> \"violinist\"<\/span>)<\/span>\n<\/pre>\n<\/div>\n
0.8616064190864563\n<\/pre>\n
In this case, the similarity score between the two terms is almost the same. In both contexts (generals and domain specific), their co-occurrence is similar.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Nearest Words<\/h3>\n
\n
Now let’s look at the similarity between two distinct words in two new and distinct contexts. Let’s take a look at a few words and see what other words occur most often with them.<\/p>\n<\/div>\n
\n
Music<\/h4>\n
\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"music\"<\/span>]<\/span> []<\/span> 7)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
music<\/td>\nrevol samoilovich bunin<\/td>\nmusical<\/td>\namalgamating<\/td>\nassam.<\/td>\nvoice<\/td>\ndance.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"music\"<\/span>]<\/span> []<\/span> 8)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
music<\/td>\nclassical music<\/td>\njazz<\/td>\nMusic<\/td>\nWithout Donny Kirshner<\/td>\nsongs<\/td>\nmusicians<\/td>\ntunes<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
One observation we can make is that the terms from the musicians model are more general than the ones from the general model.<\/p>\n<\/div>\n<\/div>\n
\n
Track<\/h4>\n
\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"track\"<\/span>]<\/span> []<\/span> 10)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
track<\/td>\nreleased.<\/td>\nalbum<\/td>\nlatest<\/td>\nentitled<\/td>\nreleased<\/td>\ndebut<\/td>\nyear.<\/td>\ntitled<\/td>\npositive<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"track\"<\/span>]<\/span> []<\/span> 5)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
track<\/td>\ntracks<\/td>\nTrack<\/td>\nracetrack<\/td>\nhorseshoe shaped section<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
As we know, track<\/code> is ambiguous. The difference between these two sets of nearest related words is striking. There is a clear conceptual correlation in the musicians’ domain-specific model. But in the general model, it is really going in all directions.<\/p>\n<\/div>\n<\/div>\n
\n
Year<\/h4>\n
\n
Now let’s take a look at a really general word: year<\/code><\/p>\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"year\"<\/span>]<\/span> []<\/span> 11)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
year<\/td>\nghantous.<\/td>\nhe was grammy<\/td>\nnaacap<\/td>\ngrammy award for best<\/td>\nluces del alma<\/td>\nyear.<\/td>\ngrammy award<\/td>\ngrammy for best<\/td>\nsitorai sol<\/td>\nnominated<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"year\"<\/span>]<\/span> []<\/span> 10)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
year<\/td>\nmonth<\/td>\nweek<\/td>\nmonths<\/td>\ndecade<\/td>\nyears<\/td>\nsummer<\/td>\nyear.The<\/td>\nSeptember<\/td>\nweeks<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
This one is quite interesting too. Both groups of words makes sense, but only in their respective contexts. With the musicians’ model, year<\/code> is mostly related to awards (like the Grammy Awards 2016), categories like “song of the year”, etc.<\/p>\n
In the context of the general model, year is really related to time concepts: months, seasons, etc.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Playing With Co-Occurrences Vectors<\/h3>\n
\n
Finally we will play with manipulating the co-occurrences vectors by manipulating them. A really popular word2vec equation is king - man + women = queen<\/code>. What is happening under the hood with this equation is that we are adding and substracting the co-occurences vectors for each of these words, and we check the nearest word of the resulting co-occurence vector.<\/p>\n
Now, let’s take a look at a few of these equations.<\/p>\n<\/div>\n
\n
Pianist + Renowned = ?<\/h4>\n
\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"pianist\"<\/span> \"renowned\"<\/span>]<\/span> []<\/span> 9)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
pianist<\/td>\nrenowned<\/td>\nteacher.<\/td>\ncomposer.<\/td>\nprolific<\/td>\nvirtuoso<\/td>\nteacher<\/td>\nleading<\/td>\neducator.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"pianist\"<\/span> \"renowned\"<\/span>]<\/span> []<\/span> 7)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
renowned<\/td>\npianist<\/td>\npianist composer<\/td>\njazz pianist<\/td>\nclassical pianists<\/td>\ncomposer pianist<\/td>\nvirtuoso pianist<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
These kind of operations are kind of interesting. If we add the two co-occurrence vectors for pianist<\/code> and renowned<\/code> then we get that a teacher<\/code>, an educator<\/code>, a composer<\/code> or a virtuoso<\/code> is a renowned pianist.<\/p>\n
For unambiguous surface forms like pianist<\/code>, then the two models score quite well. The difference between the two examples comes from the way the general training corpus has been created (pre-processed) compared to the musicians corpus.<\/p>\n<\/div>\n<\/div>\n
\n
Metal + Death = ?<\/h4>\n
\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"metal\"<\/span> \"death\"<\/span>]<\/span> []<\/span> 10)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
metal<\/td>\ndeath<\/td>\nthrash<\/td>\ndeathcore<\/td>\nmelodic<\/td>\ndoom<\/td>\ngrindcore<\/td>\nmetalcore<\/td>\nmathcore<\/td>\nheavy<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"metal\"<\/span> \"death\"<\/span>]<\/span> []<\/span> 5)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
death<\/td>\nmetal<\/td>\nTunstallbled<\/td>\nsteel<\/td>\nDeath<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
This example uses two quite general words with no apparent relationship between them. The results with the musicians’ model are all the highly similar genre of music like trash metal<\/code>, deathcore metal<\/code>, etc.<\/p>\n
However with the general model, it is a mix of multiple unrelated concepts.<\/p>\n<\/div>\n<\/div>\n
\n
Metal – Death + Smooth = ?<\/h4>\n
\n
Let’s play some more with these equations. What if we want some kind of smooth metal?<\/p>\n
\n
(<\/span>.wordsNearest<\/span> musicians-model [<\/span>\"metal\"<\/span> \"smooth\"<\/span>]<\/span> [<\/span>\"death\"<\/span>]<\/span> 5)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
smooth<\/td>\nfusion<\/td>\nfunk<\/td>\nhard<\/td>\nneo<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
This one is quite interesting. We substracted the death<\/code> co-occurrence vector to the metal<\/code> one, and then we added the smooth<\/code> vector. What we end-up with is a bunch of music genres that are much smoother than death metal<\/code>.<\/p>\n
\n
(<\/span>.wordsNearest<\/span> google-news-model [<\/span>\"metal\"<\/span> \"smooth\"<\/span>]<\/span> [<\/span>\"death\"<\/span>]<\/span> 5)<\/span>\n<\/pre>\n<\/div>\n\n\n\n\n\n\n<\/colgroup>\n\n\n
 
smooth<\/td>\nmetal<\/td>\nBrushed aluminum<\/td>\ndurable polycarbonate<\/td>\nchromed steel<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
In the case of the general model, we end-up with “smooth metal”. The removal of the death<\/code> vector has no effect on the results, probably since these are three ambiguous and really general terms.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
What Is Next<\/h2>\n
\n
The demo I presented in this article uses public datasets currently linked to KBpedia. You may wonder what are the other possibilities? Another possibility is to link your own private datasets to KBpedia<\/a>. That way, these private datasets would then become usable, exactly in the same way, to create domain-specific training corpuses on the fly. Another possibility would be to take totally unstructured text like local text documents, or semi-structured text like a set of HTML web pages. Then, tag them using the Cognonto topics analyzer<\/a> to tag each of the text document using KBpedia reference concepts. Then we could use the KBpedia structure exactly the same way to choose which of these documents we want to include in the domain-specific training corpus.<\/p>\n<\/div>\n<\/div>\n
\n
Conclusion<\/h2>\n
\n
As we saw, creating domain-specific training corpuses to use with word2vec can have a dramatic impact on the results and how results can be much more meaningful within the scope of that domain. Another advantage of the domain-specific training corpuses is that they create much smaller models. This is quite an interesting characteristic since smaller models means they are faster to generate, faster to download\/upload, faster to query, consumes less memory, etc.<\/p>\n
Of the concepts in KBpedia, roughly 33,000 of them correspond to types (or classes) of various sorts. These pre-determined slices are available across all needs and domains to generate such domain-specific corpuses. Further, KBpedia is designed for rapid incorporation of your own domain information to add further to this discriminatory power.<\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
word2vec is a two layer artificial neural network used to process text to learn relationships between words within a text corpus to create a model of all the relationships between the words of that corpus. The text corpus that a word2vec process uses to learn the relationships between words is called the training corpus. In […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[293,251,287,84],"tags":[288,197,289,193,231,291],"class_list":["post-3344","post","type-post","status-publish","format-standard","hentry","category-artificial-intelligence","category-clojure","category-cognonto","category-semantic-web","tag-cognonto","tag-data","tag-machinelearning","tag-nlp","tag-semanticweb","tag-word2vec"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3344","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=3344"}],"version-history":[{"count":7,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3344\/revisions"}],"predecessor-version":[{"id":3498,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3344\/revisions\/3498"}],"wp:attachment":[{"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=3344"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=3344"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fgiasson.com\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=3344"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}