fasttext 0.1.0 → 0.1.1

data/vendor/fastText/website/README.md

@@ -1,6 +0,0 @@
-Prerequisites
-- nodejs
-
-To build locally, navigate into subfolder website and execute
-- npm install
-- npm run start

data/vendor/fastText/website/blog/2016-08-18-blog-post.md

@@ -1,42 +0,0 @@
----
-title: Releasing fastText
-author: Edouard Grave
-authorURL: https://research.fb.com/people/grave-edouard/
-authorFBID: 534178442
----
-
-## Faster, better text classification!
-
-Understanding the meaning of words that roll off your tongue as you talk, or your fingertips as you tap out posts is one of the biggest technical challenges facing artificial intelligence researchers. But it is an essential need. Automatic text processing forms a key part of the day-to-day interaction with your computer; it’s a critical component of everything from web search and content ranking to spam filtering, and when it works well, it’s completely invisible to you. With the growing amount of online data, there is a need for more flexible tools to better understand the content of very large datasets, in order to provide more accurate classification results.
-
-To address this need, the [Facebook AI Research (FAIR) lab](https://research.fb.com/category/facebook-ai-research-fair/) is open-sourcing [fastText](https://github.com/facebookresearch/fastText), a library designed to help build scalable solutions for text representation and classification. Our ongoing commitment to collaboration and sharing with the community extends beyond just delivering code. We know it’s important to share our learnings to advance the field, so have also [published](http://arxiv.org/abs/1607.04606) [our research](http://arxiv.org/abs/1607.01759) relating to fastText.
-
-FastText combines some of the most successful concepts introduced by the natural language processing and machine learning communities in the last few decades. These include representing sentences with bag of words and bag of n-grams, as well as using subword information, and sharing information across classes through a hidden representation. We also employ a hierachical softmax that takes advantage of the unbalanced distribution of the classes to speed up computation. These different concepts are being used for two different tasks: efficient text classification and learning word vector representations.
-
-<!--truncate-->
-
-## Efficient learning for text classification
-
-Deep neural networks have recently become very popular for text processing. While these models achieve very good performance in limited laboratory practice, they can be slow to train and test, which limits their use on very large datasets.
-
-FastText helps solve this problem. To be efficient on datasets with very large number of categories, it uses a hierarchical classifier instead of a flat structure, in which the different categories are organized in a tree (think binary tree instead of list). This reduces the time complexities of training and testing text classifiers from linear to logarithmic with respect to the number of classes. FastText also exploits the fact that classes are imbalanced (some classes appearing more often than other) by using the Huffman algorithm to build the tree used to represent categories. The depth in the tree of very frequent categories is therefore smaller than for infrequent ones, leading to further computational efficiency.
-
-FastText also represents a text by a low dimensional vector, which is obtained by summing vectors corresponding to the words appearing in the text. In fastText, a low dimensional vector is associated to each word of the vocabulary. This hidden representation is shared across all classifiers for different categories, allowing information about words learned for one category to be used by other categories. These kind of representations, called bag of words, ignore word order. In fastText we also use vectors to represent word ngrams to take into account local word order, which is important for many text classification problems.
-
-Our experiments show that fastText is often on par with deep learning classifiers in terms of accuracy, and many orders of magnitude faster for training and evaluation. With fastText, we were often able to cut training times from several days to just a few seconds, and achieve state-of-the-art performance on many standard problems, such as sentiment analysis or tag prediction.
-
-![fastText performance](../../../../img/blog/2016-08-18-blog-post-img1.png)
-_Comparison between fastText and deep learning-based methods._
-
-## A dedicated tool
-
-Text classification is very important in the commercial world; spam or clickbait filtering being perhaps the most ubiquitous example. There are tools that design models for general classification problems (such as Vowpal Wabbit or libSVM), but fastText is exclusively dedicated to text classification. This allows it to be quickly trained on extremely large datasets. We have seen results of models trained on more than 1 billion words in less than 10 minutes using a standard multicore CPU. FastText can also classify a half-million sentences among more than 300,000 categories in less than five minutes.
-
-## Works on many languages
-
-Besides text classification, fastText can also be used to learn vector representations of words. It has been designed to work on a variety of languages, including English, German, Spanish, French, and Czech, by taking advantage of the languages morphological structure. It uses a simple yet effective way of incorporating subword information that turns out to work very well for morphologically rich languages like Czech, demonstrating that carefully designed character ngram features are strong source of information to enrich the word representations. FastText can achieve significantly better performance than the popular [word2vec](https://code.google.com/archive/p/word2vec/) tool, or other state-of-the-art morphological word representations.
-
-![fastText performance](../../../../img/blog/2016-08-18-blog-post-img2.png)
-_Comparison between fastText and state-of-the-art word representations for different languages._
-
-We hope the introduction of fastText helps the community build better, more scalable solutions for text representation and classification. Delivered as an open-source library, we believe fastText is a valuable addition to the research and engineering communities, which will ultimately help us all design better applications and further advances in language understanding.

data/vendor/fastText/website/blog/2017-05-02-blog-post.md

@@ -1,60 +0,0 @@
----
-title: fastText on mobile
-author: Armand Joulin
-authorURL: https://research.fb.com/people/joulin-armand/
-authorFBID: 696297201
----
-
-Today, the Facebook AI Research (FAIR) team released pre-trained vectors in 294 languages, accompanied by two quick-start tutorials, to increase fastText’s accessibility to the large community of students, software developers, and researchers interested in machine learning. fastText’s models now fit on smartphones and small computers like Raspberry Pi devices thanks to a new functionality that reduces memory usage.
-
-First open-sourced last summer, [fastText](https://github.com/facebookresearch/fastText) was designed to be accessible to anyone with generic hardware like notebooks and X86 cloud instances, or almost any platform with enough memory. Smartphone and small computer support extend fastText’s accessibility to an even larger community and a greater range of applications.
-
-<!--truncate-->
-
-### fastText on small memory devices
-
-To reach more people and more applications via mobile phones and other internet-connected devices, this release contains a new functionality that reduces the memory consumed by fastText models. The typical model built on earlier versions use a few gigabytes of memory; this new feature helps to reduce memory to as little as a few hundred kilobytes.
-
-Squeezing models into reduced memory footprints was made possible through collaboration with the FAIR team that recently released [FAISS](https://github.com/facebookresearch/faiss), an open source library for efficient similarity search and clustering of high-dimensional vectors. The FAIR fastText team published “[FastText.zip: Compressing Text Classification Models](https://arxiv.org/pdf/1612.03651.pdf),” which describes the combination of the two research projects that enabled the reduction to overcome the challenges to shipping models on small memory devices.
-
-### Simple yet state-of-the-art text classifier
-
-fastText is designed to be simple to use for developers, domain experts, and students. Its speed allows you to iterate quickly and refine your models without specialized hardware. fastText models can be trained on more than a billion words on any multicore CPU in less than few minutes and can classify half a million sentences with hundreds of thousands of classes in less than a minute.
-
-fastText classification compares favorably with more complex neural network architectures implemented for specialized GPU hardware. The performance comparisons were reported in another paper authored by the fastText team, “[Bag of Tricks for Efficient Text Classification](https://arxiv.org/pdf/1607.01759.pdf).” Little or no accuracy is lost with fastText compared with more complex neural network models. For example, fastText performed competitively on sentiment analysis problems when compared to the results of convolutional neural networks (Zhang et al. 2015).
-
-![fastText performance](../../../../img/blog/2017-05-02-blog-post-img1.jpg)
-
-## How Facebook AI Research engineered fastText’s performance
-
-Throughout the history of machine learning, research developments have often outpaced hardware performance, and researchers have worked to optimize for practical applications by maximizing accuracy while minimizing computational complexity. Facebook's research teams have developed unique expertise in fitting the best possible model to the hardware available. With fastText, however, one additional constraint is extending machine learning capabilities to everyone who has a multicore CPU computer with a C++ compiler — pretty much everyone developing software or in an engineering role.
-
-Given this expertise, we were able to build a simple yet powerful library to solve important text classification problems tailored for generic, less powerful hardware. fastText is both impactful as a library for learning text classification and for adding accurate text classification features to applications. fastText also enables developers to add text classification features such as ranking comments with hashtags and ranking reviews based on sentiment analysis without a formal machine learning education.
-
-Low dimensional vectors were used to improve performance. Large vectors improve accuracy because of the larger number of features in the word vector but are computationally expensive at training time. State of the art performance is possible with low dimensional vectors if the right features are present and the models can scale to a very large corpus. During encoding, vector size is reduced by presenting examples of low dimensional vectors obtained through conventional optimization methods.
-
-Training time is reduced using a hierarchical softmax based on the Huffman coding tree (a binary tree variant). In operation, search times for the most likely class is also reduced, because each leaf of the tree representing a word vector has an associated probability. Leaves on lower branches have associated descending probabilities. Calculating the probability over the path rapidly narrows to the most likely path as lower probability branches are discarded.
-
-fastText uses a bag-of-words model to extract features and a linear classifier to train the model. Because the bag-of-words model does not recognize sentence word order, the generalized contextual features of high-frequency words are not shared with low-frequency words, resulting in lower accuracy proportional to lower word frequency. Replacing the bag-of-words model with an n-gram model that recognizes word order would share features of high-frequency word vectors with lower frequency word vectors, but would add complexity, training time, and computational expense. Using fastText, partial n-gram information can be applied during training time as a training setting by selecting the number of words before and after the subject word in a sentence to balance training time and accuracy.
-
-fastText can achieve better performance than the popular word2vec tool, or other state-of-the-art morphological word representations, and includes many more languages. fastText will receive future improvements from the FAIR team and fastText community making it more accessible.
-
-Even though the accuracy is comparable, fastText is much faster. When compared with state-of-the-art neural network based models, fastText is 1,000 to 10,000 times faster. This is the result of the simplicity of its implementation that uses low-rank linear models and standard features like bigrams.
-
-The table below is an indication of fastText’s performance.
-
-![fastText performance](../../../../img/blog/2017-05-02-blog-post-img2.jpg)
-
-
-## Self-paced fastText tutorials
-
-One of the tutorials accompanying this release explains supervised text classification. By stepping through the tutorial, the developer gains experience building a simple text classifier on a custom dataset. Then the tutorial explains how to tune the model to attain the best possible performance.
-
-fastText is designed to be extremely fast. This guarantees the responsiveness that developers need to quickly iterate over different settings that affect accuracy. For example, n-grams improve the accuracy of applications like sentiment analysis where word order is important. Hierarchical softmax is shown to increase the speed of applications like hashtag predication where the output space is large.
-
-In the second tutorial, fastText is used to learn word representations from Wikipedia pages. The tutorial steps through simple ways to test the quality of a model. Queries return a word’s nearest neighbors or given a related pair example, analogies produce the most closely related words to a a queried word. For example, a model can predict that Paris is related to France in the same way as Berlin to Germany. Even words that the model has not been trained on can be tested! fastText looks at groups of characters that build-up the word to produce its representation to find likely candidates for misspelled words and made-up words like ”shiftgear.”
-
-Students and developers interested in machine learning can get right to work with the newly released self-paced tutorials [available on our website](https://fasttext.cc/docs/en/supervised-tutorial.html). The tutorials are straightforward and do not require advanced knowledge in machine learning. The tutorials also offer insights into other features of the fastText library for more advanced developers.
-
-Use cases include experimentation, prototyping, and production. fastText can be used as a command line, linked to a C++ application, or used as a library. Community contributed Python and Lua APIs are also available.
-

data/vendor/fastText/website/blog/2017-10-02-blog-post.md

@@ -1,90 +0,0 @@
----
-title: Language identification
-author: Edouard Grave
-authorURL: https://research.fb.com/people/grave-edouard/
-authorFBID: 534178442
----
-
-## Fast and accurate language identification using fastText
-
-We are excited to announce that we are publishing a fast and accurate tool for text-based language identification. It can recognize more than 170 languages, takes less than 1MB of memory and can classify thousands of documents per second. It is based on fastText library and is released [here](https://fasttext.cc/docs/en/language-identification.html) as open source, free to use by everyone. We are releasing several versions of the model, each optimized for different memory usage, and compared them to the popular tool [langid.py](https://github.com/saffsd/langid.py).
-
-<!--truncate-->
-
-![Evaluation of our models](../../../../img/blog/2017-10-02-blog-post-img1.png)
-
-Our tool uses various features offered by the fastText library, such as subwords or model compression. In the remainder of this blogpost, we will explain how these work, and how to use them to build a fast and small language detector.
-
-
-## Training your own language detector
-
-Building a fast and small language detector with fastText can be done with a few command lines, as we will show below. First, we need a dataset to train our model. Here, we propose to use sentences from the Tatoeba website, which can be downloaded from https://tatoeba.org/eng/downloads. Note that for the sake of simplicity, we use a small quantity of data for this blogpost . If you want to train a state-of-the-art model comparable with our pre-trained model, you will need to use a larger quantity of data.
-
-### Training data 
-
-First, let's download the training data:
-
-```bash
->> wget http://downloads.tatoeba.org/exports/sentences.tar.bz2
->> bunzip2 sentences.tar.bz2
->> tar xvf sentences.tar
-```
-Then, we need to put our training data into fastText format, which is easily done using:
-```bash
->> awk -F"\t" '{print"__label__"$2" "$3}' < sentences.csv | shuf > all.txt
-```
-We can then split our training data into training and validation sets:
-```bash
->> head -n 10000 all.txt > valid.txt
->> tail -n +10001 all.txt > train.txt
-```
-### First model
-We can now train our first model
-```bash
->> ./fasttext supervised -input train.txt -output langdetect -dim 16
-```
-and test it on the held out data:
-```bash
->> ./fasttext test langdetect.bin valid.txt
-```
-This model should have an accuracy around 96.5%. Let's see if we can do better, by changing the default parameters.
-
-### Using subword features
-
-The first way to improve our baseline model is to use subword features, which enhance the classifier by taking into account the structure of words. It uses a simple, yet effective way of incorporating such information: each word is represented by the set of all character ngrams of a given length appearing in that word. As an example, when using subwords of length 3, the word skiing is represented by
-
-    { skiing, ski, kii, iin, ing }
-
-A key advantage of these features is that out-of-vocabulary words, such as misspelled words, can still be represented at test time by their subwords representations. This make text classifiers much more robust, especially for problems with small training sets, or for morphologically rich languages. Users can enable these features by simply specifying the value of the minimum and maximum character ngram size with the command line options -minn and -maxn:
-```bash
->> ./fasttext supervised -input train.txt -output langdetect -dim 16 -minn 2 -maxn 4
-```
-In that case, fastText now uses all the character ngrams of length 2, 3 and 4. The accuracy of the classifier should improve, and be above 98.5%. We can also make the training and testing faster, by using the hierarchical softmax:
-```bash
->> ./fasttext supervised -input train.txt -output langdetect -dim 16 -minn 2 -maxn 4 -loss hs
-```
-### Model compression
-
-Finally, we can make the size of the model file much smaller, by using model compression:
-```bash
->> ./fasttext quantize -input train.txt -output langdetect -qnorm -cutoff 50000 -retrain
-```
-After running this command line, you should get a new model, langdetect.ftz, with a file size smaller than 1MB (instead of 350MB for the original model).
-
-How does model quantization work? It is quite simple, and relies on two operations: weight quantization and feature selection. We now briefly describe these two operations in detail.
-
-**Weight quantization.** The first operation is to compress the weights of the models using a technique called vector quantization. Quantization is the process of mapping values from a large set (e.g. floating point numbers) to a smaller set (e.g. bytes). Here, we use a variant which is well suited to compress vectors, instead of scalar values. The algorithm, called product quantization, works as follow. First, each vector is split into smaller vectors, for example of dimension 2. Then, we run the k-means algorithm on these sub-vectors, and represent each sub-vector by the closest centroid obtained with k-means. Therefore, each 2-dimension vector is now represented by 1 byte (to store the centroid), instead of 8 bytes (to store the 2 floats), therefore achieving a compression rate of 8. If we instead split the vectors into sub-vectors of dimension 4, we can achieve a compression rate of 16 (but often with a higher distortion rate). This tradeoff between compression and distortion can be controlled using the -dsub command line option, which set the dimension of the sub-vectors.
-
-**Feature selection.** The second operation we apply to compress models is to remove features which do not have a big influence on the decision of the classifier. For this, our goal is to find the model with a given number of feature (e.g. 50,000 in the previous example) which is the closest from the original model. The solution of this problem is to keep the features (either words, subwords, or ngrams), which have the vectors with the largest norms.
-
-### References
-
-* [Quantization](https://en.wikipedia.org/wiki/Quantization_%28signal_processing%29)
-* [Vector quantization](https://en.wikipedia.org/wiki/Vector_quantization)
-* [k-means algorithm](https://en.wikipedia.org/wiki/K-means_clustering)
-* [Feature selection](https://en.wikipedia.org/wiki/Feature_selection)
-
-### ISO codes of languages supported
-```
-af als am an ar arz as ast av az azb ba bar bcl be bg bh bn bo bpy br bs bxr ca cbk ce ceb ckb co cs cv cy da de diq dsb dty dv el eml en eo es et eu fa fi fr frr fy ga gd gl gn gom gu gv he hi hif hr hsb ht hu hy ia id ie ilo io is it ja jbo jv ka kk km kn ko krc ku kv kw ky la lb lez li lmo lo lrc lt lv mai mg mhr min mk ml mn mr mrj ms mt mwl my myv mzn nah nap nds ne new nl nn no oc or os pa pam pfl pl pms pnb ps pt qu rm ro ru rue sa sah sc scn sco sd sh si sk sl so sq sr su sv sw ta te tg th tk tl tr tt tyv ug uk ur uz vec vep vi vls vo wa war wuu xal xmf yi yo yue zh
-```

data/vendor/fastText/website/blog/2019-06-25-blog-post.md

@@ -1,168 +0,0 @@
----
-title: New release of python module
-author: Onur Çelebi
-authorURL: https://research.fb.com/people/celebi-onur/
-authorFBID: 663146146
----
-
-Today, we are happy to release a new version of the fastText python library. The main goal of this release is to merge two existing python modules: the official `fastText` module which was available on our github repository and the unofficial `fasttext` module which was available on pypi.org. We hope that this new version will address the confusion due to the previous existence of two similar, but different, python modules.
-
-The new version of our library is now available on [pypi.org](https://pypi.org/project/fasttext/) as well as on our github repository, and you can find [an overview of its API here](/docs/en/python-module.html).
-
-
-
-fastText vs fasttext: what happened?
-----------------------------------
-There was an ongoing confusion among our user community about the existence of both `fastText` and `fasttext` modules.
-
-When fastText was first released in 2016, it was a command line only utility. Very soon, people wanted to use fastText's capabilities from python without having to call a binary for each action. In August 2016, [Bayu Aldi Yansyah](https://github.com/pyk), a developer outside of Facebook, published a python wrapper of fastText. His work was very helpful to a lot of people in our community and he published his unofficial python library on pypi with the pretty straighforward module name `fasttext` (note the lowercase `t`).
-
-Later, our team began to work on an official python binding of fastText, that was published under the same github repository as the C++ source code. However, the module name for this official library was `fastText` (note the uppercase `T`).
-
-Last year, Bayu Aldi Yansyah gave us admin access to the pypi project so that we could merge the two libraries.
-
-To sum up, we ended up with two libraries that had:
-
-- almost the same name
-- different APIs
-- different versions
-- different ways to install
-
-That was a very confusing situation for the community.
-
-What actions did we take?
---------------------------
-Today we are merging the two python libraries. We decided to keep the official API and top level functions such as `train_unsupervised` and `train_supervised` as well as returning numpy objects. We remove `cbow`, `skipgram` and `supervised` functions from the unofficial API. However, [we bring nice ideas](#wordvectormodel-and-supervisedmodel-objects) from the unofficial API to the official one. In particular, we liked the pythonic approach of `WordVectorModel`. This new python module is named `fasttext`, and is available on both [pypi](https://pypi.org/project/fasttext/) and our [github](https://github.com/facebookresearch/fastText) repository.
-
-From now, we will refer to the tool as "fastText", however the name of the python module is `fasttext`.
-
-
-
-What is the right way to do now?
---------------------------------
-
-Before, you would either use `fastText` (uppercase `T`):
-```python
-import fastText
-# and call:
-fastText.train_supervised
-fastText.train_unsupervised
-```
-
-or use `fasttext` (lowercase `t`):
-```python
-import fasttext
-# and call:
-fasttext.cbow
-fasttext.skipgram
-fasttext.supervised
-```
-
-
-Now, the right way to do is to
-`import fasttext` (lowercase `t`)
-and use
-```python
-import fasttext
-# and call:
-fasttext.train_supervised
-fasttext.train_unsupervised
-```
-
-We are keeping the lowercase `fasttext` module name, while we keep the `fastText` API.
-
-This is because:
-
-- the standard way to name python modules is all lowercases
-- the API from `fastText` is exposing numpy arrays, which is widely used by the machine learning community.
-
-
-You can find a more comprehensive overview of our python API [here](/docs/en/python-module.html).
-
-Should I modify my existing code?
----------------------------------
-Depending on the version of the python module you were using, you might need to do some little modifications on your existing code.
-
-### 1) You were using the official `fastText` module:
-
-You don't have to do much. Just replace your `import fastText` lines by `import fasttext` and everything should work as usual.
-
-### 2) You were using the unofficial `fasttext` module:
-
-If you were using the functions `cbow`, `skipgram`, `supervised` and/or `WordVectorModel`, `SupervisedModel` objects, you were using the unofficial `fasttext` module.
-
-Updating your code should be pretty straightforward, but it still implies some little changes.
-
-#### `cbow` function: use `train_unsupervised` instead.
-For example, replace:
-
-```
-fasttext.cbow("train.txt", "model_file", lr=0.05, dim=100, ws=5, epoch=5)
-```
-with
-```
-model = fasttext.train_unsupervised("train.txt", model='cbow', lr=0.05, dim=100, ws=5, epoch=5)
-model.save_model("model_file.bin")
-```
-
-#### `skipgram` function: use `train_unsupervised` instead.
-For example, replace:
-
-```
-fasttext.skipgram("train.txt", "model_file", lr=0.05, dim=100, ws=5, epoch=5)
-```
-with
-```
-model = fasttext.train_unsupervised("train.txt", model='skipgram', lr=0.05, dim=100, ws=5, epoch=5)
-model.save_model("model_file.bin")
-```
-
-
-#### `supervised` function: use `train_supervised` instead
-For example, replace:
-```
-fasttext.supervised("train.txt", "model_file", lr=0.1, dim=100, epoch=5, word_ngrams=2, loss='softmax')
-```
-with
-```
-model = fasttext.train_supervised("train.txt", lr=0.1, dim=100, epoch=5, , word_ngrams=2, loss='softmax')
-model.save_model("model_file.bin")
-```
-
-#### Parameters
-
-- As you can see, you can use either `word_ngrams` or `wordNgrams` as parameter name. Because the parameter names from the unofficial API are mapped to the official ones: `min_count` to `minCount`, `word_ngrams` to `wordNgrams`, `lr_update_rate` to `lrUpdateRate`, `label_prefix` to `label` and `pretrained_vectors` to `pretrainedVectors`.
-- `silent` parameter is not supported. Use `verbose` parameter instead.
-- `encoding` parameter is not supported, every input should be encoded in `utf-8`.
-
-
-### `WordVectorModel` and `SupervisedModel` objects
-
-Instead of `WordVectorModel` and `SupervisedModel` objects, we return a model object that mimics some nice ideas from the unofficial API.
-
-```python
-model = fasttext.train_unsupervised("train.txt", model='skipgram')
-print(model.words)      # list of words in dictionary
-print(model['king'])    # get the vector of the word 'king'
-print('king' in model)  # check if a word is in dictionary
-```
-
-
-
-```python
-model = fasttext.train_supervised("train.txt")
-print(model.words)      # list of words in dictionary
-print(model.labels)     # list of labels
-```
-
-The model object also contains the arguments of the training:
-
-```python
-print(model.epoch)
-print(model.loss)
-print(model.wordNgrams)
-```
-
-Thank you!
-------------
-We want to thank our incredible community. We truly appreciate your feedback, a big thank you to everyone reporting issues and contributing to the project. In particular we want to express how grateful we are to [Bayu Aldi Yansyah](https://github.com/pyk) who did a great job with his python library and for giving us the ownership of the pypi `fasttext` project.

data/vendor/fastText/website/core/Footer.js

@@ -1,127 +0,0 @@
-/**
- * Copyright (c) 2017-present, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-const React = require("react");
-
-const githubButton = (
-  <a
-    className="github-button"
-    href="https://github.com/facebookresearch/fastText/"
-    data-icon="octicon-star"
-    data-count-href="/fastText/stargazers"
-    data-count-api="/repos/fastText#stargazers_count"
-    data-count-aria-label="# stargazers on GitHub"
-    aria-label="Star this project on GitHub"
-  >
-    Star
-  </a>
-);
-
-class Footer extends React.Component {
-  render() {
-    const language = this.props.language || "en";
-    const currentYear = new Date().getFullYear();
-    return (
-      <footer className="nav-footer" id="footer">
-        <section className="sitemap">
-          <a href={this.props.config.baseUrl} className="nav-home">
-            <img
-              src={this.props.config.baseUrl + this.props.config.footerIcon}
-              alt={this.props.config.title}
-            />
-          </a>
-          <div>
-            <h5>Support</h5>
-            <a
-              href={
-                this.props.config.baseUrl + "docs/" + language + "/support.html"
-              }
-            >
-              Getting Started
-            </a>
-            <a
-              href={
-                this.props.config.baseUrl +
-                "docs/" +
-                language +
-                "/supervised-tutorial.html"
-              }
-            >
-              Tutorials
-            </a>
-            <a
-              href={
-                this.props.config.baseUrl +
-                "docs/" +
-                language +
-                "/faqs.html"
-              }
-            >
-              FAQs
-            </a>
-            <a
-              href={
-                this.props.config.baseUrl +
-                "docs/" +
-                language +
-                "/api.html"
-              }
-            >
-              API
-            </a>
-          </div>
-          <div>
-            <h5>Community</h5>
-            <a
-              href="https://www.facebook.com/groups/1174547215919768/"
-              target="_blank"
-            >
-              Facebook Group
-            </a>
-            <a
-              href="http://stackoverflow.com/questions/tagged/fasttext"
-              target="_blank"
-            >
-              Stack Overflow
-            </a>
-            <a
-              href="https://groups.google.com/forum/#!forum/fasttext-library"
-              target="_blank"
-            >
-              Google Group
-           </a>
-          </div>
-          <div>
-            <h5>More</h5>
-            <a href={this.props.config.baseUrl + "blog"}>Blog</a>
-            <a href="https://github.com/facebookresearch/fastText" target="_blank">GitHub</a>
-            {githubButton}
-          </div>
-        </section>
-
-        <a
-          href="https://code.facebook.com/projects/"
-          target="_blank"
-          className="fbOpenSource"
-        >
-          <img
-            src={this.props.config.baseUrl + "img/oss_logo.png"}
-            alt="Facebook Open Source"
-            width="170"
-            height="45"
-          />
-        </a>
-        <section className="copyright">
-          Copyright &copy; {currentYear} Facebook Inc.
-        </section>
-      </footer>
-    );
-  }
-}
-
-module.exports = Footer;