Repository: eonu/sequentia

Issue:
KNN classifier labels
Hi,

Thank you for the great documentation and scripts. I think there is something missing in the method "_find_nearest" in the class "KNNClassifier". I will try to illustrate it with an example, let's assume the labels for the closest neighbors, sorted by closeness is nearest_label =  [1 0 0 0 1] and we are using uniform distances so nearest_distance is [1 1 1 1 1].  We expect the prediction to be 0, since there are 3 zeros, but using the code in "_find_nearest", we would get 1.

```
import numpy as np
nearest_labels = np.array([1, 0, 0, 0, 1])
nearest_distances = np.array([1, 1, 1, 1, 1])
labels_distances = np.vstack((nearest_labels, nearest_distances));
labels_distances = labels_distances[:, labels_distances[0, :].argsort()]
i = np.nonzero(np.diff(labels_distances[0, :]))[0] + 1
i = np.insert(i, 0, 0)
label_scores = np.add.reduceat(labels_distances[1, :], I)
max_labels = nearest_labels[np.argmax(label_scores)]
print (max_labels)
```

In particular, I don't understand the reasoning for this line

```
max_labels = nearest_labels[np.argmax(label_scores)]

```
I believe this should be replaced by 

```
ordered_labels = np.array(sorted(list(set(nearest_labels))))
max_labels = ordered_labels [np.argmax(label_scores)]
```
This would give the expected result of 0.

Discussion:

Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 86a8835..6cf6340 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,15 @@
 ## [0.12.1](https://github.com/eonu/sequentia/releases/tag/v0.12.1)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 
 - Remove `requirements.py` due to import error. ([#182](https://github.com/eonu/sequentia/pull/182))
 
 ## [0.12.0](https://github.com/eonu/sequentia/releases/tag/v0.12.0)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Rework preprocessing module (see [#177](https://github.com/eonu/sequentia/pull/177)). ([#179](https://github.com/eonu/sequentia/pull/179))
   - Add `Custom` transformation.
@@ -38,6 +42,8 @@
 
 ## [0.11.1](https://github.com/eonu/sequentia/releases/tag/v0.11.1)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Fix validation for univariate sequences. ([#164](https://github.com/eonu/sequentia/pull/164))
 
@@ -47,6 +53,8 @@
 
 ## [0.11.0](https://github.com/eonu/sequentia/releases/tag/v0.11.0)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add trailing underscore to variables containing trainable parameters (see #154). ([#158](https://github.com/eonu/sequentia/pull/158))
 - Add properties for GMM emission distribution parameters (see #153). ([#156](https://github.com/eonu/sequentia/pull/156))
@@ -63,6 +71,8 @@
 
 ## [0.10.3](https://github.com/eonu/sequentia/releases/tag/v0.10.3)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Fix `setup.py` encoding problem. ([#145](https://github.com/eonu/sequentia/pull/145))
 - Add `docs/robots.txt` and `sphinx-version-warning` package to prevent search engines from indexing old package versions (see #143). ([#147](https://github.com/eonu/sequentia/pull/147))
@@ -72,6 +82,8 @@
 
 ## [0.10.2](https://github.com/eonu/sequentia/releases/tag/v0.10.2)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add support for dependent feature warping (addresses [#124](https://github.com/eonu/sequentia/pull/124)). ([#135](https://github.com/eonu/sequentia/pull/135))
 - Add multi-processed predictions for `HMMClassifier` (addresses [#121](https://github.com/eonu/sequentia/pull/121)). ([#136](https://github.com/eonu/sequentia/pull/136))
@@ -84,12 +96,16 @@
 
 ## [0.10.1](https://github.com/eonu/sequentia/releases/tag/v0.10.1)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Minor changes
 - Remove references to `sigment`. ([#130](https://github.com/eonu/sequentia/pull/130))
 - Fix type specifiers in documentation (see [#129](https://github.com/eonu/sequentia/issues/129)). ([#131](https://github.com/eonu/sequentia/pull/131))
 
 ## [0.10.0](https://github.com/eonu/sequentia/releases/tag/v0.10.0)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Switch out [`pomegranate`](https://github.com/jmschrei/pomegranate) HMM backend to [`hmmlearn`](https://github.com/hmmlearn/hmmlearn). ([#105](https://github.com/eonu/sequentia/pull/105))
 - Remove separate HMM and GMM-HMM implementations – only keep a single GMM-HMM implementation (in the `GMMHMM` class) and treat multivariate Gaussian emission HMM as a special case of GMM-HMM. ([#105](https://github.com/eonu/sequentia/pull/105))
@@ -112,11 +128,15 @@
 
 ## [0.7.2](https://github.com/eonu/sequentia/releases/tag/v0.7.2)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Stop referring to sequences as temporal, as non-temporal sequences can also be used. ([#103](https://github.com/eonu/sequentia/pull/103))
 
 ## [0.7.1](https://github.com/eonu/sequentia/releases/tag/v0.7.1)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Fix deserialization for `KNNClassifier`. ([#93](https://github.com/eonu/sequentia/pull/93))
   - Sort HDF5 keys before loading as `numpy.ndarray`s.
@@ -124,6 +144,8 @@
 
 ## [0.7.0](https://github.com/eonu/sequentia/releases/tag/v0.7.0)
 
+> ⚠️: `KNNClassifier` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Fix `pomegranate` version to v0.12.0. ([#79](https://github.com/eonu/sequentia/pull/79))
 - Add serialization and deserialization support for all classifiers. ([#80](https://github.com/eonu/sequentia/pull/80))
@@ -143,6 +165,8 @@
 
 ## [v0.7.0a1](https://github.com/eonu/sequentia/releases/tag/v0.7.0a1)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Clean up package imports. ([#77](https://github.com/eonu/sequentia/pull/77))
 - Rework `preprocessing` module. ([#75](https://github.com/eonu/sequentia/pull/75))
@@ -152,6 +176,8 @@
 
 ## [0.6.1](https://github.com/eonu/sequentia/releases/tag/v0.6.1)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Remove strict requirement of Numpy arrays being two-dimensional by using `numpy.atleast_2d` to convert one-dimensional arrays into 2D. ([#70](https://github.com/eonu/sequentia/pull/70))
 
@@ -160,6 +186,8 @@
 
 ## [0.6.0](https://github.com/eonu/sequentia/releases/tag/v0.6.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add package tests and Travis CI support. ([#56](https://github.com/eonu/sequentia/pull/56))
 - Remove Python v3.8+ support. ([#56](https://github.com/eonu/sequentia/pull/56))
@@ -174,6 +202,8 @@
 
 ## [0.5.0](https://github.com/eonu/sequentia/releases/tag/v0.5.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add `Preprocess.summary()` to display an ordered summary of preprocessing transformations. ([#54](https://github.com/eonu/sequentia/pull/54))
 - Add mean and median filtering preprocessing methods. ([#48](https://github.com/eonu/sequentia/pull/48))
@@ -189,6 +219,8 @@
 
 ## [0.4.0](https://github.com/eonu/sequentia/releases/tag/v0.4.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Re-add `euclidean` metric as `DTWKNN` default. ([#43](https://github.com/eonu/sequentia/pull/43))
 
@@ -197,11 +229,15 @@
 
 ## [0.3.0](https://github.com/eonu/sequentia/releases/tag/v0.3.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add proper documentation, hosted on [Read The Docs](https://sequentia.readthedocs.io/en/latest). ([#40](https://github.com/eonu/sequentia/pull/40), [#41](https://github.com/eonu/sequentia/pull/41))
 
 ## [0.2.0](https://github.com/eonu/sequentia/releases/tag/v0.2.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 - Add multi-processing support for `DTWKNN` predictions. ([#29](https://github.com/eonu/sequentia/pull/29))
 - Rename the `fit_transform()` function in `Preprocess` to `transform()` since there is nothing being fitted. ([#35](https://github.com/eonu/sequentia/pull/35))
@@ -219,5 +255,7 @@
 
 ## [0.1.0](https://github.com/eonu/sequentia/releases/tag/v0.1.0)
 
+> ⚠️: `DTWKNN` has a major bug in this version resulting in inaccurate predictions (see [#186](https://github.com/eonu/sequentia/issues/186)) — **please use v0.13.0 or later**.
+
 #### Major changes
 Nothing, initial release!
\ No newline at end of file
diff --git a/README.md b/README.md
index e168231..d74929b 100644
--- a/README.md
+++ b/README.md
@@ -233,12 +233,9 @@ All contributions to this repository are greatly appreciated. Contribution guide
 		<tr>
 			<th align="center">
         <a href="https://github.com/eonu">
-          <img src="https://avatars0.githubusercontent.com/u/24795571?s=460&v=4" alt="Edwin Onuonga" width="60px">
-          <br/><sub><b>Edwin Onuonga</b></sub>
+          <img src="https://avatars0.githubusercontent.com/u/24795571?s=460&v=4" alt="eonu" width="60px">
+          <br/><sub><b>eonu</b></sub>
         </a>
-        <br/>
-        <a href="mailto:ed@eonu.net">✉️</a>
-        <a href="https://eonu.net">🌍</a>
 			</th>
       <th align="center">
         <a href="https://github.com/Prhmma">
@@ -246,6 +243,12 @@ All contributions to this repository are greatly appreciated. Contribution guide
           <br/><sub><b>Prhmma</b></sub>
         </a>
 			</th>
+      <th align="center">
+        <a href="https://github.com/manisci">
+          <img src="https://avatars.githubusercontent.com/u/30268711?v=4" alt="manisci" width="60px">
+          <br/><sub><b>manisci</b></sub>
+        </a>
+      </th>
 			<!-- Add more <th></th> blocks for more contributors -->
 		</tr>
 	</thead>
diff --git a/lib/sequentia/classifiers/hmm/hmm_classifier.py b/lib/sequentia/classifiers/hmm/hmm_classifier.py
index 083175d..5981b25 100644
--- a/lib/sequentia/classifiers/hmm/hmm_classifier.py
+++ b/lib/sequentia/classifiers/hmm/hmm_classifier.py
@@ -212,8 +212,8 @@ class HMMClassifier:
     def _chunk_predict(self, process, posteriors, chunk, verbose): # Requires fit
         """Makes predictions (scores) for a chunk of the observation sequences, for a given subprocess."""
         return np.array([posteriors(x) for x in tqdm.auto.tqdm(
-            chunk, desc='Classifying examples (process {})'.format(process),
-            disable=not(verbose), position=process-1
+            chunk, desc='Predicting (process {})'.format(process),
+            disable=not(verbose), position=process-1, leave=False
         )])
 
     @property
diff --git a/lib/sequentia/classifiers/knn/knn_classifier.py b/lib/sequentia/classifiers/knn/knn_classifier.py
index 45e2d6f..9ccfdb1 100644
--- a/lib/sequentia/classifiers/knn/knn_classifier.py
+++ b/lib/sequentia/classifiers/knn/knn_classifier.py
@@ -1,4 +1,5 @@
-import warnings, tqdm, tqdm.auto, numpy as np, types, pickle, marshal
+import warnings, types, pickle, marshal, numpy as np
+from tqdm.auto import tqdm
 from joblib import Parallel, delayed
 from multiprocessing import cpu_count
 from dtaidistance import dtw, dtw_ndim
@@ -116,9 +117,9 @@ class KNNClassifier:
                 if isinstance(weighting(np.ones(5)), np.ndarray):
                     self._weighting = weighting
                 else:
-                    raise TypeError('Expected weighting function to accept a numpy.ndarray and return an equally-sized numpy.ndarray')
+                    raise TypeError('Expected weighting function to accept a numpy.ndarray and return an equally sized numpy.ndarray')
             except:
-                raise TypeError('Expected weighting function to accept a numpy.ndarray and return an equally-sized numpy.ndarray')
+                raise TypeError('Expected weighting function to accept a numpy.ndarray and return an equally sized numpy.ndarray')
 
         self._use_c = self._val.is_boolean(use_c, desc='whether or not to use fast pure C compiled functions')
         if self._use_c and (dtw_cc is None):
@@ -158,9 +159,7 @@ class KNNClassifier:
             Whether to display a progress bar or not.
 
             .. note::
-                If both ``verbose=True`` and ``n_jobs > 1``, then the progress bars for each process
-                are always displayed in the console, regardless of where you are running this function from
-                (e.g. a Jupyter notebook).
+                The progress bar cannot be displayed if both ``verbose=True`` and ``n_jobs > 1``.
 
         n_jobs: int > 0 or -1
             | The number of jobs to run in parallel.
@@ -179,15 +178,30 @@ class KNNClassifier:
         self._val.is_boolean(original_labels, desc='original_labels')
         self._val.is_boolean(verbose, desc='verbose')
         self._val.is_restricted_integer(n_jobs, lambda x: x == -1 or x > 0, 'number of jobs', '-1 or greater than zero')
+        n_jobs = min(cpu_count() if n_jobs == -1 else n_jobs, len(X))
 
+        # Make prediction for a single sequence
         if isinstance(X, np.ndarray):
-            distances = np.array([self._dtw(X, x) for x in tqdm.auto.tqdm(self._X_, desc='Calculating distances', disable=not(verbose))])
-            return self._output(self._find_nearest(distances), original_labels)
+            if n_jobs > 1:
+                warnings.warn('Single kNN predictions do not yet support multi-processing. Set n_jobs=1 to silence this warning.')
+
+            labels = self._predict(X, verbose=verbose)
+
+        # Make predictions for multiple sequences (in parallel)
         else:
-            n_jobs = min(cpu_count() if n_jobs == -1 else n_jobs, len(X))
-            X_chunks = [list(chunk) for chunk in np.array_split(np.array(X, dtype=object), n_jobs)]
-            labels = Parallel(n_jobs=n_jobs)(delayed(self._chunk_predict)(i+1, chunk, verbose) for i, chunk in enumerate(X_chunks))
-            return self._output(np.concatenate(labels), original_labels) # Flatten the resulting array
+            if n_jobs == 1:
+                # Use entire list as a chunk
+                labels = self._chunk_predict(X, verbose=verbose)
+
+            else:
+                if verbose:
+                    warnings.warn('Progress bars cannot be displayed when using multiple processes. Set verbose=False to silence this warning.')
+
+                # Split X into n_jobs equally sized chunks and process in parallel
+                chunks = [list(chunk) for chunk in np.array_split(np.array(X, dtype=object), n_jobs)]
+                labels = np.concatenate(Parallel(n_jobs=n_jobs)(delayed(self._chunk_predict)(chunk) for chunk in chunks))
+
+        return self._output(labels, original_labels)
 
     def evaluate(self, X, y, verbose=True, n_jobs=1):
         """Evaluates the performance of the classifier on a batch of observation sequences and their labels.
@@ -238,7 +252,6 @@ class KNNClassifier:
             pickle.dump({
                 'k': self._k,
                 'classes': self._encoder_.classes_,
-                # Serialize the weighting function into a byte-string
                 'weighting': marshal.dumps((self._weighting.__code__, self._weighting.__name__)),
                 'window': self._window,
                 'use_c': self._use_c,
@@ -266,34 +279,34 @@ class KNNClassifier:
         with open(path, 'rb') as file:
             data = pickle.load(file)
 
-            # Check deserialized object dictionary and keys
-            keys = set(('k', 'classes', 'weighting', 'window', 'use_c', 'independent', 'random_state', 'X', 'y', 'n_features'))
-            if not isinstance(data, dict):
-                raise TypeError('Expected deserialized object to be a dictionary - make sure the object was serialized with the save() function')
-            else:
-                if len(set(keys) - set(data.keys())) != 0:
-                    raise ValueError('Missing keys in deserialized object dictionary – make sure the object was serialized with the save() function')
-
-            # Deserialize the weighting function
-            weighting, name = marshal.loads(data['weighting'])
-            weighting = types.FunctionType(weighting, globals(), name)
-
-            # Instantiate a new KNNClassifier with the same hyper-parameters
-            clf = cls(
-                k=data['k'],
-                classes=data['classes'],
-                weighting=weighting,
-                window=data['window'],
-                use_c=data['use_c'],
-                independent=data['independent'],
-                random_state=data['random_state']
-            )
-
-            # Load the data directly
-            clf._X_, clf._y_ = data['X'], data['y']
-            clf._n_features_ = data['n_features']
-
-            return clf
+        # Check deserialized object dictionary and keys
+        keys = set(('k', 'classes', 'weighting', 'window', 'use_c', 'independent', 'random_state', 'X', 'y', 'n_features'))
+        if not isinstance(data, dict):
+            raise TypeError('Expected deserialized object to be a dictionary - make sure the object was serialized with the save() function')
+        else:
+            if len(set(keys) - set(data.keys())) != 0:
+                raise ValueError('Missing keys in deserialized object dictionary – make sure the object was serialized with the save() function')
+
+        # Deserialize the weighting function
+        weighting, name = marshal.loads(data['weighting'])
+        weighting = types.FunctionType(weighting, globals(), name)
+
+        # Instantiate a new KNNClassifier with the same hyper-parameters
+        clf = cls(
+            k=data['k'],
+            classes=data['classes'],
+            weighting=weighting,
+            window=data['window'],
+            use_c=data['use_c'],
+            independent=data['independent'],
+            random_state=data['random_state']
+        )
+
+        # Load the data directly
+        clf._X_, clf._y_ = data['X'], data['y']
+        clf._n_features_ = data['n_features']
+
+        return clf
 
     def _dtw_1d(self, a, b, window): # Requires fit
         """Computes the DTW distance between two univariate sequences."""
@@ -309,50 +322,54 @@ class KNNClassifier:
         window = max(1, int(self._window * max(len(A), len(B))))
         return dtw_ndim.distance(A, B, use_c=self._use_c, window=window)
 
-    def _argmax(self, a):
-        """Same as numpy.argmax but returns all occurrences of the maximum, and is O(n) instead of O(2n).
+    def _multi_argmax(self, arr):
+        """Same as numpy.argmax but returns all occurrences of the maximum and only requires a single pass.
         From: https://stackoverflow.com/a/58652335
         """
-        all_, max_ = [0], a[0]
-        for i in range(1, len(a)):
-            if a[i] > max_:
-                all_, max_ = [i], a[i]
-            elif a[i] == max_:
+        all_, max_ = [0], arr[0]
+        for i in range(1, len(arr)):
+            if arr[i] > max_:
+                all_, max_ = [i], arr[i]
+            elif arr[i] == max_:
                 all_.append(i)
         return np.array(all_)
 
-    def _find_nearest(self, distances): # Requires fit
-        """Returns the mode label of the k nearest neighbors.
+    def _find_k_nearest(self, distances): # Requires fit
+        """Returns the labels and weightings (or scores) of the k-nearest neighbors"""
+        idx = np.argpartition(distances, self._k)[:self._k]
+        return self._y_[idx], self._weighting(distances[idx])
+
+    def _find_max_labels(self, nearest_labels, nearest_scores):
+        """Returns the mode label(s) of the k nearest neighbors.
         Vectorization from: https://stackoverflow.com/a/49239335
         """
-        # Find the indices, labels and distances of the k-nearest neighbours
-        idx = np.argpartition(distances, self._k)[:self._k]
-        nearest_labels = self._y_[idx]
-        nearest_distances = self._weighting(distances[idx])
-        # Combine labels and distances into one array and sort by label
-        labels_distances = np.vstack((nearest_labels, nearest_distances))
-        labels_distances = labels_distances[:, labels_distances[0, :].argsort()]
-        # Find indices where the label changes
-        i = np.nonzero(np.diff(labels_distances[0, :]))[0] + 1
-        i = np.insert(i, 0, 0)
-        # Add-reduce weighted distances within each label group (ordered by label)
-        label_scores = np.add.reduceat(labels_distances[1, :], i)
-        # Find the mode labels (set of labels with labels scores equal to the maximum)
-        max_labels = nearest_labels[self._argmax(label_scores)]
+        # Sort the labels in ascending order (and sort distances in the same order)
+        sorted_labels_idx = nearest_labels.argsort()
+        sorted_labels, sorted_scores = nearest_labels[sorted_labels_idx], nearest_scores[sorted_labels_idx]
+        # Identify the indices where the sorted labels change (so we can group by labels)
+        change_idx = np.concatenate(([0], np.nonzero(np.diff(sorted_labels))[0] + 1))
+        # Calculate the total score for each label
+        label_scores = np.add.reduceat(sorted_scores, change_idx)
+        # Find the change index of the maximum score(s)
+        max_score_idx = change_idx[self._multi_argmax(label_scores)]
+        # Map the change index back to the actual label(s)
+        return sorted_labels[max_score_idx]
+
+    def _chunk_predict(self, chunk, verbose=False): # Requires fit
+        """Makes predictions for multiple observation sequences."""
+        return np.array([self._predict(x) for x in tqdm(chunk, desc='Predicting', disable=not(verbose))])
+
+    def _predict(self, x1, verbose=False): # Requires fit
+        """Makes a prediction for a single observation sequence."""
+        # Calculate DTW distances between x1 and all other sequences
+        distances = np.array([self._dtw(x1, x2) for x2 in tqdm(self._X_, desc='Calculating distances', disable=not(verbose))])
+        # Find the k-nearest neighbors by DTW distance
+        nearest_labels, nearest_scores = self._find_k_nearest(distances)
+        # Out of the k-nearest neighbors, find the label(s) which had the highest total weighting
+        max_labels = self._find_max_labels(nearest_labels, nearest_scores)
         # Randomly pick from the set of labels with the maximum label score
         return self._random_state.choice(max_labels)
 
-    def _chunk_predict(self, process, chunk, verbose): # Requires fit
-        """Makes predictions for a chunk of the observation sequences, for a given subprocess."""
-        labels = np.zeros(len(chunk), dtype=int)
-        for i, sequence in enumerate(tqdm.auto.tqdm(chunk,
-            desc='Classifying examples (process {})'.format(process),
-            disable=not(verbose), position=process-1)
-        ):
-            distances = np.array([self._dtw(sequence, x) for x in self._X_])
-            labels[i] = self._find_nearest(distances)
-        return labels
-
     def _output(self, out, original_labels):
         """Inverse-transforms the labels if necessary, and returns them."""
         if isinstance(out, np.ndarray):
diff --git a/notebooks/3a - KNNClassifier.ipynb b/notebooks/3a - KNNClassifier.ipynb
index 17911b5..baa838d 100644
--- a/notebooks/3a - KNNClassifier.ipynb
+++ b/notebooks/3a - KNNClassifier.ipynb
@@ -282,9 +282,14 @@
    "outputs": [],
    "source": [
     "# Create and fit a kNN classifier using the single nearest neighbor\n",
-    "clf = KNNClassifier(k=1, classes=range(10), \n",
-    "    weighting=(lambda x: np.exp(-x)), window=0.2, \n",
-    "    use_c=True, independent=True)\n",
+    "clf = KNNClassifier(\n",
+    "    k=1, \n",
+    "    classes=range(10), \n",
+    "    weighting=(lambda x: np.exp(-x)), \n",
+    "    window=0.2,\n",
+    "    use_c=True, \n",
+    "    independent=True\n",
+    ")\n",
     "clf.fit(mfcc_train, train_set.labels)"
    ]
   },
@@ -306,15 +311,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 968 ms, sys: 130 ms, total: 1.1 s\n",
-      "Wall time: 19min 36s\n"
+      "CPU times: user 432 ms, sys: 89.1 ms, total: 521 ms\n",
+      "Wall time: 39.6 s\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
     "\n",
-    "acc, cm = clf.evaluate(mfcc_test, test_set.labels, n_jobs=-1)"
+    "acc, cm = clf.evaluate(mfcc_test, test_set.labels, verbose=False, n_jobs=-1)"
    ]
   },
   {
@@ -367,7 +372,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -381,7 +386,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.10"
+   "version": "3.9.7"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/3b - GMMHMM & HMMClassifier.ipynb b/notebooks/3b - GMMHMM & HMMClassifier.ipynb
index ed3a187..8c4e2b3 100644
--- a/notebooks/3b - GMMHMM & HMMClassifier.ipynb
+++ b/notebooks/3b - GMMHMM & HMMClassifier.ipynb
@@ -341,7 +341,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4f84ca6034ce4ecdae07de2bc80e314d",
+       "model_id": "7493917b722d41889f02a88276247221",
        "version_major": 2,
        "version_minor": 0
       },
@@ -356,23 +356,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 10min 2s, sys: 1min 1s, total: 11min 3s\n",
-      "Wall time: 7min 8s\n"
+      "CPU times: user 2min 34s, sys: 15.3 s, total: 2min 49s\n",
+      "Wall time: 1min 21s\n"
      ]
     }
    ],
    "source": [
     "%%time\n",
     "\n",
+    "# Convert lists to numpy arrays for easy indexing\n",
+    "mfcc_train_np = np.array(mfcc_train, dtype=object)\n",
+    "train_labels_np = np.array(train_set.labels)\n",
+    "\n",
     "hmms = []\n",
     "for digit in tqdm(range(10), desc='Training HMMs'):\n",
     "    # Create a linear HMM with 5 states and 10 components in the GMM emission state distributions\n",
-    "    hmm = GMMHMM(label=digit, n_states=10, n_components=10, topology='left-right', random_state=rng)\n",
+    "    hmm = GMMHMM(label=digit, n_states=5, n_components=10, topology='linear', random_state=rng)\n",
     "    # Set random initial state distributions and transition matrix according to the linear topology\n",
     "    hmm.set_random_initial()\n",
     "    hmm.set_random_transitions()\n",
     "    # Fit each HMM only on the observation sequences which had that label\n",
-    "    hmm.fit([mfcc_train[i] for i, label in enumerate(train_set.labels) if label == digit])\n",
+    "    hmm.fit(mfcc_train_np[train_labels_np == digit].tolist())\n",
     "    hmms.append(hmm)\n",
     "    \n",
     "clf = HMMClassifier()\n",
@@ -400,12 +404,963 @@
     }
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Predicting (process 1):   0%|          | 0/150 [00:00<?, ?it/s]\n",
+      "\n",
+      "Predicting (process 3):   0%|          | 0/150 [00:00<?, ?it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   1%|          | 1/150 [00:00<00:24,  5.99it/s]A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   1%|          | 1/150 [00:00<00:25,  5.94it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   1%|          | 1/150 [00:00<00:26,  5.72it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   1%|          | 1/150 [00:00<00:27,  5.40it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   1%|▏         | 2/150 [00:00<00:27,  5.48it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   1%|▏         | 2/150 [00:00<00:27,  5.36it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):   2%|▏         | 3/150 [00:00<00:25,  5.77it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   2%|▏         | 3/150 [00:00<00:25,  5.76it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   2%|▏         | 3/150 [00:00<00:26,  5.53it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   2%|▏         | 3/150 [00:00<00:25,  5.67it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):   3%|▎         | 4/150 [00:00<00:26,  5.46it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   3%|▎         | 4/150 [00:00<00:26,  5.50it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   3%|▎         | 4/150 [00:00<00:26,  5.56it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   3%|▎         | 5/150 [00:00<00:25,  5.66it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   3%|▎         | 5/150 [00:00<00:26,  5.37it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   3%|▎         | 5/150 [00:00<00:26,  5.44it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   4%|▍         | 6/150 [00:01<00:27,  5.24it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   4%|▍         | 6/150 [00:01<00:28,  5.03it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   4%|▍         | 6/150 [00:01<00:28,  5.01it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   5%|▍         | 7/150 [00:01<00:26,  5.34it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   5%|▍         | 7/150 [00:01<00:27,  5.13it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   5%|▍         | 7/150 [00:01<00:27,  5.21it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   5%|▌         | 8/150 [00:01<00:27,  5.21it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   5%|▌         | 8/150 [00:01<00:27,  5.22it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):   5%|▌         | 8/150 [00:01<00:28,  5.07it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   6%|▌         | 9/150 [00:01<00:25,  5.50it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   6%|▌         | 9/150 [00:01<00:26,  5.33it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):   6%|▌         | 9/150 [00:01<00:27,  5.14it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   7%|▋         | 10/150 [00:01<00:26,  5.23it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   7%|▋         | 10/150 [00:01<00:26,  5.28it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):   7%|▋         | 10/150 [00:01<00:26,  5.27it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):   7%|▋         | 11/150 [00:02<00:27,  5.03it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   7%|▋         | 11/150 [00:02<00:28,  4.82it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):   7%|▋         | 11/150 [00:02<00:28,  4.83it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):   8%|▊         | 12/150 [00:02<00:26,  5.19it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   8%|▊         | 12/150 [00:02<00:27,  5.06it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   8%|▊         | 12/150 [00:02<00:28,  4.92it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   9%|▊         | 13/150 [00:02<00:27,  5.03it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   9%|▊         | 13/150 [00:02<00:26,  5.09it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   9%|▊         | 13/150 [00:02<00:27,  5.00it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):   9%|▉         | 14/150 [00:02<00:26,  5.14it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):   9%|▉         | 14/150 [00:02<00:26,  5.12it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):   9%|▉         | 14/150 [00:02<00:26,  5.14it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  10%|█         | 15/150 [00:02<00:26,  5.17it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  10%|█         | 15/150 [00:02<00:26,  5.15it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  10%|█         | 15/150 [00:02<00:25,  5.22it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  11%|█         | 16/150 [00:03<00:24,  5.43it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  11%|█         | 16/150 [00:03<00:25,  5.24it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  11%|█▏        | 17/150 [00:03<00:24,  5.38it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  11%|█▏        | 17/150 [00:03<00:25,  5.30it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  11%|█▏        | 17/150 [00:03<00:25,  5.23it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  11%|█▏        | 17/150 [00:03<00:26,  5.10it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  12%|█▏        | 18/150 [00:03<00:24,  5.30it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  12%|█▏        | 18/150 [00:03<00:26,  5.05it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  13%|█▎        | 19/150 [00:03<00:24,  5.42it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  13%|█▎        | 19/150 [00:03<00:24,  5.34it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  13%|█▎        | 20/150 [00:03<00:23,  5.57it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  13%|█▎        | 20/150 [00:03<00:23,  5.42it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  13%|█▎        | 20/150 [00:03<00:24,  5.39it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  14%|█▍        | 21/150 [00:03<00:22,  5.61it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  14%|█▍        | 21/150 [00:03<00:23,  5.47it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  14%|█▍        | 21/150 [00:04<00:24,  5.28it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  15%|█▍        | 22/150 [00:04<00:22,  5.60it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  15%|█▍        | 22/150 [00:04<00:22,  5.61it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  15%|█▍        | 22/150 [00:04<00:22,  5.59it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  15%|█▌        | 23/150 [00:04<00:22,  5.62it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  15%|█▌        | 23/150 [00:04<00:22,  5.72it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  15%|█▌        | 23/150 [00:04<00:22,  5.61it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  16%|█▌        | 24/150 [00:04<00:22,  5.58it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  16%|█▌        | 24/150 [00:04<00:22,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  16%|█▌        | 24/150 [00:04<00:22,  5.56it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  17%|█▋        | 25/150 [00:04<00:21,  5.68it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  17%|█▋        | 25/150 [00:04<00:21,  5.80it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  17%|█▋        | 25/150 [00:04<00:21,  5.75it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  17%|█▋        | 25/150 [00:04<00:22,  5.57it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  17%|█▋        | 26/150 [00:04<00:22,  5.54it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  17%|█▋        | 26/150 [00:04<00:21,  5.64it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  17%|█▋        | 26/150 [00:04<00:21,  5.70it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  18%|█▊        | 27/150 [00:05<00:22,  5.38it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  18%|█▊        | 27/150 [00:05<00:22,  5.42it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  18%|█▊        | 27/150 [00:05<00:22,  5.56it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  19%|█▊        | 28/150 [00:05<00:21,  5.71it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  19%|█▊        | 28/150 [00:05<00:21,  5.65it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  19%|█▉        | 29/150 [00:05<00:20,  5.77it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  19%|█▉        | 29/150 [00:05<00:21,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  19%|█▉        | 29/150 [00:05<00:20,  5.77it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  20%|██        | 30/150 [00:05<00:20,  5.94it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  20%|██        | 30/150 [00:05<00:20,  5.77it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  21%|██        | 31/150 [00:05<00:20,  5.80it/s]\u001b[A\n",
+      "Predicting (process 2):  21%|██        | 31/150 [00:05<00:20,  5.87it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  21%|██        | 31/150 [00:05<00:20,  5.88it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  21%|██▏       | 32/150 [00:05<00:19,  6.01it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  21%|██▏       | 32/150 [00:05<00:19,  6.04it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  21%|██▏       | 32/150 [00:05<00:19,  5.95it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  21%|██▏       | 32/150 [00:05<00:20,  5.74it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  22%|██▏       | 33/150 [00:06<00:20,  5.74it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  22%|██▏       | 33/150 [00:06<00:20,  5.82it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  22%|██▏       | 33/150 [00:06<00:20,  5.81it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  23%|██▎       | 34/150 [00:06<00:19,  5.90it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  23%|██▎       | 34/150 [00:06<00:19,  6.01it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  23%|██▎       | 35/150 [00:06<00:19,  5.98it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  23%|██▎       | 35/150 [00:06<00:19,  5.99it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  23%|██▎       | 35/150 [00:06<00:19,  6.00it/s]\u001b[A\u001b[A\u001b[A\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Predicting (process 1):  24%|██▍       | 36/150 [00:06<00:20,  5.70it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  24%|██▍       | 36/150 [00:06<00:20,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  24%|██▍       | 36/150 [00:06<00:20,  5.57it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  24%|██▍       | 36/150 [00:06<00:21,  5.43it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  25%|██▍       | 37/150 [00:06<00:19,  5.68it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  25%|██▍       | 37/150 [00:06<00:20,  5.48it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  25%|██▍       | 37/150 [00:06<00:20,  5.54it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  25%|██▌       | 38/150 [00:06<00:19,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  25%|██▌       | 38/150 [00:06<00:19,  5.70it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  26%|██▌       | 39/150 [00:07<00:19,  5.66it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  26%|██▌       | 39/150 [00:07<00:19,  5.62it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  26%|██▌       | 39/150 [00:07<00:19,  5.68it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  26%|██▌       | 39/150 [00:07<00:19,  5.62it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  27%|██▋       | 40/150 [00:07<00:19,  5.65it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  27%|██▋       | 40/150 [00:07<00:19,  5.74it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  27%|██▋       | 41/150 [00:07<00:18,  5.77it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  27%|██▋       | 41/150 [00:07<00:19,  5.73it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  27%|██▋       | 41/150 [00:07<00:18,  5.74it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  27%|██▋       | 41/150 [00:07<00:19,  5.69it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  28%|██▊       | 42/150 [00:07<00:18,  5.85it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  28%|██▊       | 42/150 [00:07<00:18,  5.87it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  28%|██▊       | 42/150 [00:07<00:19,  5.43it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  29%|██▊       | 43/150 [00:07<00:17,  6.01it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  29%|██▊       | 43/150 [00:07<00:17,  6.00it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  29%|██▊       | 43/150 [00:07<00:19,  5.37it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  29%|██▉       | 44/150 [00:07<00:17,  6.04it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  29%|██▉       | 44/150 [00:07<00:17,  6.04it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  29%|██▉       | 44/150 [00:08<00:19,  5.34it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  30%|███       | 45/150 [00:08<00:17,  5.84it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  30%|███       | 45/150 [00:08<00:17,  5.85it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  30%|███       | 45/150 [00:08<00:19,  5.35it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  31%|███       | 46/150 [00:08<00:17,  5.87it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  31%|███       | 46/150 [00:08<00:17,  5.95it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  31%|███       | 46/150 [00:08<00:18,  5.56it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  31%|███▏      | 47/150 [00:08<00:17,  5.91it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  31%|███▏      | 47/150 [00:08<00:17,  5.81it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  31%|███▏      | 47/150 [00:08<00:18,  5.68it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  32%|███▏      | 48/150 [00:08<00:18,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  32%|███▏      | 48/150 [00:08<00:17,  5.75it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  32%|███▏      | 48/150 [00:08<00:17,  5.67it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  33%|███▎      | 49/150 [00:08<00:17,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  33%|███▎      | 49/150 [00:08<00:17,  5.72it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  33%|███▎      | 49/150 [00:08<00:17,  5.69it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  33%|███▎      | 50/150 [00:08<00:17,  5.75it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  33%|███▎      | 50/150 [00:09<00:17,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  33%|███▎      | 50/150 [00:09<00:17,  5.65it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  34%|███▍      | 51/150 [00:09<00:17,  5.75it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  34%|███▍      | 51/150 [00:09<00:17,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  34%|███▍      | 51/150 [00:09<00:17,  5.79it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  35%|███▍      | 52/150 [00:09<00:16,  5.94it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  35%|███▍      | 52/150 [00:09<00:17,  5.73it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  35%|███▍      | 52/150 [00:09<00:17,  5.67it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  35%|███▌      | 53/150 [00:09<00:17,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  35%|███▌      | 53/150 [00:09<00:17,  5.61it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  35%|███▌      | 53/150 [00:09<00:16,  5.80it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  36%|███▌      | 54/150 [00:09<00:16,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  36%|███▌      | 54/150 [00:09<00:16,  5.68it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  36%|███▌      | 54/150 [00:09<00:16,  5.70it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  37%|███▋      | 55/150 [00:09<00:16,  5.79it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  37%|███▋      | 55/150 [00:09<00:16,  5.83it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  37%|███▋      | 55/150 [00:09<00:16,  5.82it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  37%|███▋      | 56/150 [00:10<00:16,  5.74it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  37%|███▋      | 56/150 [00:10<00:16,  5.73it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  38%|███▊      | 57/150 [00:10<00:15,  5.85it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  38%|███▊      | 57/150 [00:10<00:15,  5.86it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  38%|███▊      | 57/150 [00:10<00:16,  5.80it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  39%|███▊      | 58/150 [00:10<00:15,  6.00it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  39%|███▊      | 58/150 [00:10<00:15,  5.91it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  39%|███▊      | 58/150 [00:10<00:15,  5.76it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  39%|███▉      | 59/150 [00:10<00:15,  5.92it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  39%|███▉      | 59/150 [00:10<00:15,  5.92it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  39%|███▉      | 59/150 [00:10<00:15,  5.82it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 3):  40%|████      | 60/150 [00:10<00:15,  5.94it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  40%|████      | 60/150 [00:10<00:15,  5.81it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  41%|████      | 61/150 [00:10<00:15,  5.91it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  41%|████      | 61/150 [00:10<00:15,  5.86it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  41%|████      | 61/150 [00:11<00:15,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  41%|████▏     | 62/150 [00:11<00:14,  5.93it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  41%|████▏     | 62/150 [00:11<00:15,  5.78it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  41%|████▏     | 62/150 [00:11<00:15,  5.71it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  42%|████▏     | 63/150 [00:11<00:14,  5.94it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  42%|████▏     | 63/150 [00:11<00:14,  5.91it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  42%|████▏     | 63/150 [00:11<00:15,  5.73it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  43%|████▎     | 64/150 [00:11<00:14,  6.14it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  43%|████▎     | 64/150 [00:11<00:14,  5.91it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  43%|████▎     | 64/150 [00:11<00:15,  5.72it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  43%|████▎     | 65/150 [00:11<00:14,  6.03it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  43%|████▎     | 65/150 [00:11<00:14,  5.89it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  43%|████▎     | 65/150 [00:11<00:15,  5.65it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  43%|████▎     | 65/150 [00:11<00:15,  5.33it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  44%|████▍     | 66/150 [00:11<00:15,  5.34it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  44%|████▍     | 66/150 [00:11<00:14,  5.63it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  44%|████▍     | 66/150 [00:12<00:17,  4.79it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  45%|████▍     | 67/150 [00:12<00:15,  5.28it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  45%|████▍     | 67/150 [00:12<00:17,  4.83it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  45%|████▍     | 67/150 [00:12<00:18,  4.59it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  45%|████▌     | 68/150 [00:12<00:16,  4.90it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  45%|████▌     | 68/150 [00:12<00:16,  4.99it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  46%|████▌     | 69/150 [00:12<00:14,  5.43it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  45%|████▌     | 68/150 [00:12<00:16,  4.90it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  46%|████▌     | 69/150 [00:12<00:15,  5.18it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  47%|████▋     | 70/150 [00:12<00:14,  5.60it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  46%|████▌     | 69/150 [00:12<00:16,  5.02it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  47%|████▋     | 70/150 [00:12<00:14,  5.35it/s]\u001b[A\u001b[A\u001b[A\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Predicting (process 2):  47%|████▋     | 71/150 [00:12<00:13,  5.65it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  47%|████▋     | 70/150 [00:12<00:15,  5.16it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  47%|████▋     | 71/150 [00:12<00:14,  5.42it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  48%|████▊     | 72/150 [00:12<00:13,  5.74it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  47%|████▋     | 71/150 [00:12<00:14,  5.47it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  48%|████▊     | 72/150 [00:12<00:13,  5.70it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  49%|████▊     | 73/150 [00:12<00:13,  5.79it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  49%|████▊     | 73/150 [00:13<00:13,  5.62it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  48%|████▊     | 72/150 [00:13<00:14,  5.45it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  49%|████▉     | 74/150 [00:13<00:13,  5.81it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  49%|████▉     | 74/150 [00:13<00:13,  5.79it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  49%|████▊     | 73/150 [00:13<00:13,  5.52it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  50%|█████     | 75/150 [00:13<00:12,  5.87it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  50%|█████     | 75/150 [00:13<00:12,  6.04it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  49%|████▉     | 74/150 [00:13<00:13,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  51%|█████     | 76/150 [00:13<00:12,  5.87it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  51%|█████     | 76/150 [00:13<00:12,  5.95it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  50%|█████     | 75/150 [00:13<00:13,  5.62it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  51%|█████▏    | 77/150 [00:13<00:12,  6.00it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  51%|█████▏    | 77/150 [00:13<00:12,  5.81it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  51%|█████▏    | 77/150 [00:13<00:12,  5.82it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  51%|█████     | 76/150 [00:13<00:12,  5.70it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  52%|█████▏    | 78/150 [00:13<00:12,  5.91it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  51%|█████▏    | 77/150 [00:13<00:12,  5.86it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  53%|█████▎    | 79/150 [00:13<00:11,  6.05it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  53%|█████▎    | 79/150 [00:14<00:12,  5.86it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  52%|█████▏    | 78/150 [00:14<00:12,  5.78it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  53%|█████▎    | 80/150 [00:14<00:11,  5.96it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  53%|█████▎    | 80/150 [00:14<00:11,  5.92it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  53%|█████▎    | 80/150 [00:14<00:11,  5.87it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  53%|█████▎    | 79/150 [00:14<00:12,  5.78it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  54%|█████▍    | 81/150 [00:14<00:11,  5.84it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  54%|█████▍    | 81/150 [00:14<00:11,  5.98it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  53%|█████▎    | 80/150 [00:14<00:11,  5.85it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  55%|█████▍    | 82/150 [00:14<00:11,  5.79it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  54%|█████▍    | 81/150 [00:14<00:11,  5.97it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  55%|█████▌    | 83/150 [00:14<00:11,  6.02it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  55%|█████▌    | 83/150 [00:14<00:11,  5.72it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  55%|█████▌    | 83/150 [00:14<00:11,  5.86it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  55%|█████▍    | 82/150 [00:14<00:11,  6.01it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  56%|█████▌    | 84/150 [00:14<00:11,  5.81it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  56%|█████▌    | 84/150 [00:14<00:11,  6.00it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  55%|█████▌    | 83/150 [00:14<00:11,  6.04it/s]\u001b[A\n",
+      "Predicting (process 2):  57%|█████▋    | 86/150 [00:15<00:10,  6.20it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  56%|█████▌    | 84/150 [00:15<00:11,  5.97it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  57%|█████▋    | 85/150 [00:15<00:11,  5.58it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  57%|█████▋    | 86/150 [00:15<00:10,  6.26it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  57%|█████▋    | 85/150 [00:15<00:10,  6.12it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  57%|█████▋    | 86/150 [00:15<00:11,  5.42it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  59%|█████▊    | 88/150 [00:15<00:09,  6.25it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  57%|█████▋    | 86/150 [00:15<00:10,  6.08it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  58%|█████▊    | 87/150 [00:15<00:11,  5.55it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  59%|█████▉    | 89/150 [00:15<00:09,  6.31it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  58%|█████▊    | 87/150 [00:15<00:10,  5.94it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  59%|█████▊    | 88/150 [00:15<00:10,  5.67it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  60%|██████    | 90/150 [00:15<00:09,  6.16it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  59%|█████▊    | 88/150 [00:15<00:10,  5.78it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  59%|█████▉    | 89/150 [00:15<00:10,  5.59it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  61%|██████    | 91/150 [00:15<00:09,  6.21it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  59%|█████▉    | 89/150 [00:15<00:10,  5.96it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  60%|██████    | 90/150 [00:16<00:10,  5.64it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  61%|██████▏   | 92/150 [00:16<00:09,  5.96it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  60%|██████    | 90/150 [00:16<00:10,  5.80it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  61%|██████    | 91/150 [00:16<00:10,  5.56it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  62%|██████▏   | 93/150 [00:16<00:09,  5.78it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  61%|██████    | 91/150 [00:16<00:10,  5.76it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  61%|██████▏   | 92/150 [00:16<00:10,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  63%|██████▎   | 94/150 [00:16<00:09,  5.84it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  61%|██████▏   | 92/150 [00:16<00:10,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  62%|██████▏   | 93/150 [00:16<00:10,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  63%|██████▎   | 95/150 [00:16<00:09,  5.85it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  62%|██████▏   | 93/150 [00:16<00:09,  5.81it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  63%|██████▎   | 94/150 [00:16<00:09,  5.77it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  64%|██████▍   | 96/150 [00:16<00:09,  5.77it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  63%|██████▎   | 94/150 [00:16<00:09,  5.76it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  63%|██████▎   | 95/150 [00:16<00:09,  5.90it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  65%|██████▍   | 97/150 [00:16<00:08,  5.94it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  63%|██████▎   | 95/150 [00:17<00:09,  5.70it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  64%|██████▍   | 96/150 [00:17<00:09,  5.91it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  65%|██████▌   | 98/150 [00:17<00:08,  5.98it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  64%|██████▍   | 96/150 [00:17<00:09,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  65%|██████▍   | 97/150 [00:17<00:09,  5.84it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  66%|██████▌   | 99/150 [00:17<00:08,  5.97it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  65%|██████▍   | 97/150 [00:17<00:09,  5.86it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  65%|██████▌   | 98/150 [00:17<00:08,  5.90it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  67%|██████▋   | 100/150 [00:17<00:08,  6.10it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  65%|██████▌   | 98/150 [00:17<00:08,  5.83it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  66%|██████▌   | 99/150 [00:17<00:08,  5.88it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  66%|██████▌   | 99/150 [00:17<00:08,  5.84it/s]]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  67%|██████▋   | 100/150 [00:17<00:08,  5.59it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  67%|██████▋   | 100/150 [00:17<00:08,  6.06it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  67%|██████▋   | 100/150 [00:17<00:08,  5.88it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  67%|██████▋   | 101/150 [00:17<00:08,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  67%|██████▋   | 101/150 [00:17<00:08,  5.95it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  67%|██████▋   | 101/150 [00:18<00:08,  5.91it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  68%|██████▊   | 102/150 [00:18<00:08,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  68%|██████▊   | 102/150 [00:18<00:08,  5.99it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 1):  68%|██████▊   | 102/150 [00:18<00:08,  5.78it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  69%|██████▊   | 103/150 [00:18<00:08,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  69%|██████▊   | 103/150 [00:18<00:07,  5.94it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  70%|███████   | 105/150 [00:18<00:07,  6.04it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  69%|██████▊   | 103/150 [00:18<00:08,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  69%|██████▉   | 104/150 [00:18<00:07,  5.84it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  71%|███████   | 106/150 [00:18<00:07,  6.02it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  70%|███████   | 105/150 [00:18<00:07,  5.95it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  69%|██████▉   | 104/150 [00:18<00:08,  5.66it/s]\u001b[A\u001b[A\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Predicting (process 2):  71%|███████▏  | 107/150 [00:18<00:07,  6.00it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  70%|███████   | 105/150 [00:18<00:08,  5.36it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  71%|███████   | 106/150 [00:18<00:08,  5.23it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  72%|███████▏  | 108/150 [00:18<00:07,  5.34it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  71%|███████   | 106/150 [00:19<00:08,  5.35it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  71%|███████▏  | 107/150 [00:19<00:08,  5.34it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  73%|███████▎  | 109/150 [00:19<00:07,  5.42it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  71%|███████▏  | 107/150 [00:19<00:07,  5.43it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  72%|███████▏  | 108/150 [00:19<00:07,  5.44it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  73%|███████▎  | 110/150 [00:19<00:07,  5.46it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  73%|███████▎  | 109/150 [00:19<00:07,  5.59it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  72%|███████▏  | 108/150 [00:19<00:07,  5.50it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  74%|███████▍  | 111/150 [00:19<00:06,  5.65it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  73%|███████▎  | 110/150 [00:19<00:06,  5.77it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  73%|███████▎  | 109/150 [00:19<00:07,  5.41it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  75%|███████▍  | 112/150 [00:19<00:07,  5.37it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  74%|███████▍  | 111/150 [00:19<00:06,  5.72it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  73%|███████▎  | 110/150 [00:19<00:07,  5.53it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  75%|███████▌  | 113/150 [00:19<00:06,  5.54it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  75%|███████▍  | 112/150 [00:19<00:06,  5.72it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  74%|███████▍  | 111/150 [00:19<00:06,  5.82it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  76%|███████▌  | 114/150 [00:19<00:06,  5.58it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  75%|███████▌  | 113/150 [00:20<00:06,  5.77it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  75%|███████▍  | 112/150 [00:20<00:06,  5.50it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  77%|███████▋  | 115/150 [00:20<00:06,  5.36it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  75%|███████▌  | 113/150 [00:20<00:06,  5.48it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  76%|███████▌  | 114/150 [00:20<00:06,  5.28it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  77%|███████▋  | 116/150 [00:20<00:06,  5.23it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  76%|███████▌  | 114/150 [00:20<00:06,  5.52it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  77%|███████▋  | 115/150 [00:20<00:06,  5.47it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  78%|███████▊  | 117/150 [00:20<00:06,  5.37it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  77%|███████▋  | 116/150 [00:20<00:06,  5.44it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  77%|███████▋  | 115/150 [00:20<00:06,  5.30it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  79%|███████▊  | 118/150 [00:20<00:05,  5.36it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  78%|███████▊  | 117/150 [00:20<00:05,  5.57it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  77%|███████▋  | 116/150 [00:20<00:06,  5.43it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  79%|███████▉  | 119/150 [00:20<00:05,  5.36it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  79%|███████▊  | 118/150 [00:20<00:05,  5.57it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  78%|███████▊  | 117/150 [00:20<00:05,  5.57it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  80%|████████  | 120/150 [00:21<00:05,  5.49it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  79%|███████▉  | 119/150 [00:21<00:05,  5.58it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  79%|███████▊  | 118/150 [00:21<00:05,  5.51it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  81%|████████  | 121/150 [00:21<00:05,  5.62it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  80%|████████  | 120/150 [00:21<00:05,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  79%|███████▉  | 119/150 [00:21<00:05,  5.67it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  81%|████████▏ | 122/150 [00:21<00:04,  5.72it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  81%|████████  | 121/150 [00:21<00:05,  5.71it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  80%|████████  | 120/150 [00:21<00:05,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  82%|████████▏ | 123/150 [00:21<00:04,  5.50it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  81%|████████▏ | 122/150 [00:21<00:04,  5.68it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  81%|████████  | 121/150 [00:21<00:05,  5.78it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  83%|████████▎ | 124/150 [00:21<00:04,  5.49it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  82%|████████▏ | 123/150 [00:21<00:04,  5.78it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  81%|████████▏ | 122/150 [00:21<00:05,  5.47it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  83%|████████▎ | 125/150 [00:21<00:04,  5.71it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  83%|████████▎ | 124/150 [00:21<00:04,  5.85it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  82%|████████▏ | 123/150 [00:22<00:04,  5.54it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  84%|████████▍ | 126/150 [00:22<00:04,  5.70it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  83%|████████▎ | 125/150 [00:22<00:04,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  83%|████████▎ | 124/150 [00:22<00:04,  5.38it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  85%|████████▍ | 127/150 [00:22<00:04,  5.71it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  84%|████████▍ | 126/150 [00:22<00:04,  5.79it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  83%|████████▎ | 125/150 [00:22<00:04,  5.49it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  85%|████████▌ | 128/150 [00:22<00:03,  5.78it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  85%|████████▍ | 127/150 [00:22<00:03,  5.89it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  84%|████████▍ | 126/150 [00:22<00:04,  5.57it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  86%|████████▌ | 129/150 [00:22<00:03,  5.82it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  85%|████████▌ | 128/150 [00:22<00:03,  5.77it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  85%|████████▍ | 127/150 [00:22<00:04,  5.53it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  87%|████████▋ | 130/150 [00:22<00:03,  5.77it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  86%|████████▌ | 129/150 [00:22<00:03,  5.75it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  85%|████████▌ | 128/150 [00:22<00:03,  5.73it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  87%|████████▋ | 130/150 [00:23<00:03,  5.68it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  87%|████████▋ | 131/150 [00:23<00:03,  5.28it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  86%|████████▌ | 129/150 [00:23<00:03,  5.64it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  88%|████████▊ | 132/150 [00:23<00:03,  5.55it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  87%|████████▋ | 131/150 [00:23<00:03,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  87%|████████▋ | 130/150 [00:23<00:03,  5.49it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  89%|████████▊ | 133/150 [00:23<00:02,  5.75it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  88%|████████▊ | 132/150 [00:23<00:03,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  87%|████████▋ | 131/150 [00:23<00:03,  5.66it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  89%|████████▉ | 134/150 [00:23<00:02,  5.67it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  89%|████████▊ | 133/150 [00:23<00:02,  5.72it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  88%|████████▊ | 132/150 [00:23<00:03,  5.72it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  90%|█████████ | 135/150 [00:23<00:02,  5.72it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  89%|████████▉ | 134/150 [00:23<00:02,  5.74it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  89%|████████▊ | 133/150 [00:23<00:03,  5.63it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  91%|█████████ | 136/150 [00:23<00:02,  5.91it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  90%|█████████ | 135/150 [00:23<00:02,  5.67it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  89%|████████▉ | 134/150 [00:24<00:02,  5.67it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  91%|█████████▏| 137/150 [00:24<00:02,  5.84it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  91%|█████████ | 136/150 [00:24<00:02,  5.82it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  90%|█████████ | 135/150 [00:24<00:02,  5.65it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  92%|█████████▏| 138/150 [00:24<00:02,  5.79it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  91%|█████████▏| 137/150 [00:24<00:02,  6.00it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  91%|█████████▏| 137/150 [00:24<00:02,  5.63it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  91%|█████████ | 136/150 [00:24<00:02,  5.58it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  92%|█████████▏| 138/150 [00:24<00:02,  5.97it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  91%|█████████▏| 137/150 [00:24<00:02,  5.69it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  93%|█████████▎| 140/150 [00:24<00:01,  5.76it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  93%|█████████▎| 139/150 [00:24<00:01,  5.98it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Predicting (process 4):  93%|█████████▎| 139/150 [00:24<00:01,  5.66it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  92%|█████████▏| 138/150 [00:24<00:02,  5.57it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  93%|█████████▎| 140/150 [00:24<00:01,  6.00it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  93%|█████████▎| 140/150 [00:24<00:01,  5.75it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  95%|█████████▍| 142/150 [00:24<00:01,  5.98it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  93%|█████████▎| 139/150 [00:24<00:01,  5.64it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  94%|█████████▍| 141/150 [00:24<00:01,  5.75it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 2):  95%|█████████▌| 143/150 [00:25<00:01,  5.79it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  93%|█████████▎| 140/150 [00:25<00:01,  5.66it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  95%|█████████▍| 142/150 [00:25<00:01,  5.61it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  94%|█████████▍| 141/150 [00:25<00:01,  5.71it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  95%|█████████▌| 143/150 [00:25<00:01,  5.67it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  95%|█████████▌| 143/150 [00:25<00:01,  5.63it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  95%|█████████▍| 142/150 [00:25<00:01,  5.71it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  96%|█████████▌| 144/150 [00:25<00:01,  5.80it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  96%|█████████▌| 144/150 [00:25<00:01,  5.64it/s]\u001b[A\u001b[A\u001b[A\n",
+      "Predicting (process 1):  95%|█████████▌| 143/150 [00:25<00:01,  5.70it/s]\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  97%|█████████▋| 145/150 [00:25<00:00,  5.75it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  96%|█████████▌| 144/150 [00:25<00:01,  5.86it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3):  97%|█████████▋| 146/150 [00:25<00:00,  5.87it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  98%|█████████▊| 147/150 [00:25<00:00,  5.40it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  97%|█████████▋| 146/150 [00:25<00:00,  5.43it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  97%|█████████▋| 145/150 [00:25<00:00,  5.86it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  99%|█████████▊| 148/150 [00:25<00:00,  5.42it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  98%|█████████▊| 147/150 [00:26<00:00,  5.68it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  97%|█████████▋| 146/150 [00:26<00:00,  5.82it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2):  99%|█████████▉| 149/150 [00:26<00:00,  5.50it/s]\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  99%|█████████▊| 148/150 [00:26<00:00,  5.79it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  98%|█████████▊| 147/150 [00:26<00:00,  5.91it/s]\u001b[A\u001b[A\n",
+      "Predicting (process 2): 100%|██████████| 150/150 [00:26<00:00,  5.49it/s]\u001b[A\n",
+      "                                                                         \u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4):  99%|█████████▉| 149/150 [00:26<00:00,  5.66it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 3): 100%|██████████| 150/150 [00:26<00:00,  6.34it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "Predicting (process 1):  99%|█████████▊| 148/150 [00:26<00:00,  6.09it/s]\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 4): 100%|██████████| 150/150 [00:26<00:00,  6.05it/s]\u001b[A\u001b[A\u001b[A\n",
+      "\n",
+      "\n",
+      "Predicting (process 1):  99%|█████████▉| 149/150 [00:26<00:00,  6.81it/s]\u001b[A\u001b[A\u001b[A"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 209 ms, sys: 101 ms, total: 310 ms\n",
-      "Wall time: 1min 57s\n"
+      "CPU times: user 449 ms, sys: 239 ms, total: 688 ms\n",
+      "Wall time: 29.2 s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "                                                                         \r"
      ]
     }
    ],
@@ -430,7 +1385,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 504x504 with 1 Axes>"
       ]
@@ -444,7 +1399,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Accuracy: 58.83%\n"
+      "Accuracy: 59.50%\n"
      ]
     }
    ],
@@ -464,7 +1419,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -478,7 +1433,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.10"
+   "version": "3.9.7"
   },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {


Test patch:
diff --git a/lib/test/lib/classifiers/knn/test_knn_classifier.py b/lib/test/lib/classifiers/knn/test_knn_classifier.py
index 8a3c735..e1b22b2 100644
--- a/lib/test/lib/classifiers/knn/test_knn_classifier.py
+++ b/lib/test/lib/classifiers/knn/test_knn_classifier.py
@@ -39,6 +39,130 @@ def test_fit_sets_attributes():
     assert_equal(clf.y_, clf.encoder_.transform(y))
     assert clf._n_features_ == 3
 
+# ============================= #
+# KNNClassifier._multi_argmax() #
+# ============================= #
+
+def test_multi_argmax_single():
+    """Check that the correct index is returned when there is a single maximum"""
+    clf = clfs['k=1']
+    idx = clf._multi_argmax([-2, 1, 5, -1, 3, 4, 2])
+    assert list(idx) == [2]
+
+def test_multi_argmax_multiple():
+    """Check that the correct indicies are returned when there are multiple maxima"""
+    clf = clfs['k=1']
+    idx = clf._multi_argmax([-2, 1, 5, -1, 3, 5, 4, 2])
+    assert list(idx) == [2, 5]
+
+# =============================== #
+# KNNClassifier._find_k_nearest() #
+# =============================== #
+
+def test_find_k_nearest_tie_within():
+    """Check that tied labels are fetched correctly when they are in the nearest k values."""
+    clf = deepcopy(clfs['k=3'])
+    clf._y_ = clf._encoder_.transform(classes)
+    labels, scores = clf._find_k_nearest(np.array([4, 2, 1, 1, 3]))
+    assert len(labels) == clf._k
+    assert all(label in (1, 2, 3) for label in labels)
+    assert all(score == 1 for score in scores)
+
+def test_find_k_nearest_tie_partially_within():
+    """Check that a correct subset of the labels are fetched when there are more equidistant values than k."""
+    clf = deepcopy(clfs['k=3'])
+    clf._y_ = clf._encoder_.transform(classes)
+    labels, scores = clf._find_k_nearest(np.array([0, 1, 1, 1, 3]))
+    assert len(labels) == clf._k
+    assert all(label in (0, 1, 2, 3) for label in labels)
+    assert all(score == 1 for score in scores)
+
+def test_find_k_nearest_weighting():
+    """Check that the correct scores are returned for the k nearest values when a custom weighting is used."""
+    clf = deepcopy(clfs['k=3'])
+    clf._weighting = lambda x: np.exp(-x)
+    clf._y_ = clf._encoder_.transform(classes)
+    labels, scores = clf._find_k_nearest(np.array([4, 2, 1, 5, 3]))
+    assert len(labels) == clf._k
+    assert all(label in (1, 2, 4) for label in labels)
+    assert all(score in (np.exp(-1), np.exp(-2), np.exp(-3)) for score in scores)
+
+# ================================ #
+# KNNClassifier._find_max_labels() #
+# ================================ #
+
+def test_find_max_labels_uniform_two_classes():
+    """Check that the correct single maximum value is returned when a uniform weighting is used with two distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0, 0, 0, 1]),
+        nearest_scores=np.array([1, 1, 1, 1, 1])
+    )
+    assert list(max_labels) == [0]
+
+def test_find_max_labels_uniform_two_classes_tie():
+    """Check that the correct maximum values are returned when a uniform weighting is used with two distinct tied classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 1, 0, 0]),
+        nearest_scores=np.array([1, 1, 1, 1])
+    )
+    assert list(max_labels) == [0, 1]
+
+def test_find_max_labels_uniform_many_classes():
+    """Check that the correct maximum values are returned when a uniform weighting is used with multiple distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0, 0, 0, 1, 2, 2, 3]),
+        nearest_scores=np.array([1, 1, 1, 1, 1, 1, 1, 1])
+    )
+    assert list(max_labels) == [0]
+
+def test_find_max_labels_uniform_many_classes_tie():
+    """Check that the correct maximum values are returned when a uniform weighting is used with multiple tied distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0, 0, 1, 2, 2, 3, 3]),
+        nearest_scores=np.array([1, 1, 1, 1, 1, 1, 1, 1])
+    )
+    assert list(max_labels) == [0, 1, 2, 3]
+
+def test_find_max_labels_weighted_two_classes():
+    """Check that the correct single maximum value is returned when a custom weighting is used with two distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0  , 0, 0, 1]),
+        nearest_scores=np.array([1, 0.5, 1, 1, 2])
+    )
+    assert list(max_labels) == [1]
+
+def test_find_max_labels_weighted_two_classes_tie():
+    """Check that the correct maximum values are returned when a custom weighting is used with two distinct tied classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 1  , 0  , 0]),
+        nearest_scores=np.array([2, 0.5, 1.5, 1])
+    )
+    assert list(max_labels) == [0, 1]
+
+def test_find_max_labels_weighted_many_classes():
+    """Check that the correct maximum values are returned when a custom weighting is used with multiple distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0  , 0  , 0, 1  , 2  , 2, 3]),
+        nearest_scores=np.array([2, 0.5, 1.5, 1, 2.5, 2.5, 1, 3])
+    )
+    assert list(max_labels) == [1]
+
+def test_find_max_labels_weighted_many_classes_tie():
+    """Check that the correct maximum values are returned when a custom weighting is used with multiple tied distinct classes."""
+    clf = clfs['k=1']
+    max_labels = clf._find_max_labels(
+        nearest_labels=np.array([1, 0, 0  , 1  , 2   , 2   , 3  , 3]),
+        nearest_scores=np.array([1, 2, 1.5, 2.5, 1.75, 1.75, 0.5, 3])
+    )
+    assert list(max_labels) == [0, 1, 2, 3]
+
 # ======================= #
 # KNNClassifier.predict() #
 # ======================= #
@@ -112,61 +236,61 @@ def test_predict_single_k1_no_verbose(capsys):
 def test_predict_multiple_k1_verbose(capsys):
     """Verbosely predict multiple observation sequences (k=1)"""
     predictions = clfs['k=1'].predict(X, verbose=True)
-    assert 'Classifying examples' in capsys.readouterr().err
+    assert 'Predicting' in capsys.readouterr().err
     assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_k1_no_verbose(capsys):
     """Silently predict multiple observation sequences (k=1)"""
     predictions = clfs['k=1'].predict(X, verbose=False)
-    assert 'Classifying examples' not in capsys.readouterr().err
+    assert 'Predicting' not in capsys.readouterr().err
     assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_k2_verbose(capsys):
     """Verbosely predict multiple observation sequences (k=2)"""
     predictions = clfs['k=2'].predict(X, verbose=True)
-    assert 'Classifying examples' in capsys.readouterr().err
+    assert 'Predicting' in capsys.readouterr().err
     assert len(predictions) == 6
 
 def test_predict_multiple_k2_no_verbose(capsys):
     """Silently predict multiple observation sequences (k=2)"""
     predictions = clfs['k=2'].predict(X, verbose=False)
-    assert 'Classifying examples' not in capsys.readouterr().err
+    assert 'Predicting' not in capsys.readouterr().err
     assert len(predictions) == 6
 
 def test_predict_multiple_k3_verbose(capsys):
     """Verbosely predict multiple observation sequences (k=3)"""
     predictions = clfs['k=3'].predict(X, verbose=True)
-    assert 'Classifying examples' in capsys.readouterr().err
-    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c0', 'c1']
+    assert 'Predicting' in capsys.readouterr().err
+    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_k3_no_verbose(capsys):
     """Silently predict multiple observation sequences (k=3)"""
     predictions = clfs['k=3'].predict(X, verbose=False)
-    assert 'Classifying examples' not in capsys.readouterr().err
-    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c0', 'c1']
+    assert 'Predicting' not in capsys.readouterr().err
+    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_weighted_verbose(capsys):
     """Verbosely predict multiple observation sequences (weighted)"""
     predictions = clfs['weighted'].predict(X, verbose=True)
-    assert 'Classifying examples' in capsys.readouterr().err
-    assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c0', 'c1']
+    assert 'Predicting' in capsys.readouterr().err
+    assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_weighted_no_verbose(capsys):
     """Silently predict multiple observation sequences (weighted)"""
     predictions = clfs['weighted'].predict(X, verbose=False)
-    assert 'Classifying examples' not in capsys.readouterr().err
-    assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c0', 'c1']
+    assert 'Predicting' not in capsys.readouterr().err
+    assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_independent_verbose(capsys):
     """Verbosely predict multiple observation sequences with independent warping"""
     predictions = clfs['independent'].predict(X, verbose=True)
-    assert 'Classifying examples' in capsys.readouterr().err
+    assert 'Predicting' in capsys.readouterr().err
     assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_multiple_independent_no_verbose(capsys):
     """Silently predict multiple observation sequences with independent warping"""
     predictions = clfs['independent'].predict(X, verbose=False)
-    assert 'Classifying examples' not in capsys.readouterr().err
+    assert 'Predicting' not in capsys.readouterr().err
     assert list(predictions) == ['c1', 'c1', 'c0', 'c1', 'c1', 'c0']
 
 def test_predict_single():
@@ -182,12 +306,12 @@ def test_predict_single_original_labels():
 def test_predict_multiple():
     """Predict multiple observation sequences and don't return the original labels"""
     predictions = clfs['k=3'].predict(X, verbose=False, original_labels=False)
-    assert list(predictions) == [1, 1, 1, 1, 0, 1]
+    assert list(predictions) == [1, 1, 1, 1, 1, 0]
 
 def test_predict_multiple_original_labels():
     """Predict multiple observation sequences and return the original labels"""
     predictions = clfs['k=3'].predict(X, verbose=False, original_labels=True)
-    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c0', 'c1']
+    assert list(predictions) == ['c1', 'c1', 'c1', 'c1', 'c1', 'c0']
 
 # ======================== #
 # KNNClassifier.evaluate() #
@@ -196,10 +320,10 @@ def test_predict_multiple_original_labels():
 def test_evaluate():
     """Evaluate performance on some observation sequences and labels"""
     acc, cm = clfs['k=3'].evaluate(X, y)
-    assert acc == 0.5
+    assert acc == 5 / 6
     assert_equal(cm, np.array([
-        [0, 2, 0, 0, 0],
-        [1, 3, 0, 0, 0],
+        [1, 1, 0, 0, 0],
+        [0, 4, 0, 0, 0],
         [0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0]