Fix typos in the documentation (#115)

doc/changelog.rst

@@ -24,10 +24,13 @@ Version 0.12.0
 - Remove some constraints when discretizing time series (number of bins, time
   series with low variance) that impact the following classes:
 
-    + :class:`pyts.preprocessing.KBinsDiscretizer`
-    + :class:`pyts.approximation.SymbolicAggregateApproximation`
-    + :class:`pyts.bag_of_words.BagOfWords`
-    + :class:`pyts.classification.SAXVSM`
+  + :class:`pyts.preprocessing.KBinsDiscretizer`
+  + :class:`pyts.approximation.SymbolicAggregateApproximation`
+  + :class:`pyts.bag_of_words.BagOfWords`
+  + :class:`pyts.classification.SAXVSM`
+
+- Remove specific functions for the different variants of Dynamic Time Warping
+  (all ``dtw_*`` functions), only the main :func:`pyts.metrics.dtw` is kept.
 
 
 Version 0.11.0

doc/introduction.rst

@@ -107,4 +107,5 @@ The set of labels is always represented as a one-dimensional array with shape
 
 .. topic:: References
 
-    * Travis E, Oliphant. A guide to NumPy, USA: Trelgol Publishing, (2006).
+    * C. R. Harris et al., "Array programming with NumPy". Nature, 585(7825),
+      357-362 (2020).

doc/modules/classification.rst

@@ -44,10 +44,14 @@ SAXVSM
 SAX-VSM stands for **S**\ ymbolic **A**\ ggregate appro\ **X**\ imation in
 **V**\ ector **S**\ pace **M**\ odel.
 :class:`SAXVSM` is an algorithm based on the SAX representation of time
-series in a vector space model. It first transforms a time series of floats
-into a sequence of letters using the :ref:`approximation_sax` algorithm.
-Then each sequence of letters is transformed into a bag of words using a sliding
-window. Finally, a term-frequency inverse-term-frequency (tf-idf) vector is computed
+series in a vector space model. Subsequences are extracted using a sliding
+window and each subsequence of real numbers is transformed into a word
+(i.e., a sequence of symbols) using the :ref:`approximation_sax` algorithm.
+Each time series is thus transformed into a bag of words (the order of the
+words is not taken into account). For each class, all the bags of words from
+all the time series belonging to this class are combined into a single bag of
+words, leading to a bag of words for each class.
+Finally, a term-frequency inverse-term-frequency (tf-idf) vector is computed
 for each class. Predictions are made using the cosine similarity between
 the time series and the tf-idf vectors for each class. The predicted class
 is the class yielding the highest cosine similarity.

doc/modules/image.rst

@@ -12,8 +12,8 @@ information for any pair of time points :math:`(x_i, x_j)` given a time series
 :math:`(x_1, \ldots, x_n)`.
 Deep neural networks, especially convolutional neural networks, have been
 used to classify these imaged time series. While *pyts* does not provide
-deep neural networks, it provides algorithms to transform time series into
-images in the :mod:`pyts.image` module.
+utilities to build and train deep neural networks, it provides algorithms to
+transform time series into images in the :mod:`pyts.image` module.
 
 .. _image_rp:
 

examples/preprocessing/plot_transformers.py

@@ -34,6 +34,6 @@
 plt.plot(X_power[0], '--', label='PowerTransformer')
 plt.plot(X_quantile[0], '--', label='QuantileTransformer')
 plt.legend(loc='best', fontsize=8)
-plt.title('Transforming time series', fontsize=16)
+plt.title('Non-linear transformations', fontsize=16)
 plt.tight_layout()
 plt.show()

examples/transformation/plot_shapelet_transform.py

@@ -38,6 +38,6 @@
              lw=5, color='C{}'.format(i))
 
 plt.xlabel('Time', fontsize=12)
-plt.title('The four more discriminative shapelets', fontsize=14)
+plt.title('The four most discriminative shapelets', fontsize=14)
 plt.legend(loc='best', fontsize=8)
 plt.show()