Merge pull request #442 from unit8co/develop

Release 0.10.1

Author: hrzn

CHANGELOG.md

@@ -4,7 +4,16 @@
 Darts is still in an early development phase and we cannot always guarantee backwards compatibility. Changes that may **break code which uses a previous release of Darts** are marked with a "🔴".
 
 ## [Unreleased](https://github.com/unit8co/darts/tree/develop)
-[Full Changelog](https://github.com/unit8co/darts/compare/0.10.0...develop)
+[Full Changelog](https://github.com/unit8co/darts/compare/0.10.1...develop)
+
+## [0.10.1](https://github.com/unit8co/darts/tree/0.10.0) (2021-08-19)
+### For users of the library:
+
+**Fixed:**
+- A bug with memory pinning that was causing issues with training models on GPUs.
+
+**Changed:**
+- Clarified conda support on the README
 
 ## [0.10.0](https://github.com/unit8co/darts/tree/0.10.0) (2021-08-13)
 ### For users of the library:
@@ -15,7 +24,7 @@ argument, but it wasn't always clear whether this represented "past-observed" or
 We have made this clearer. Now all covariate-aware models support `past_covariates` and/or `future_covariates` argument 
 in their `fit()` and `predict()` methods, which makes it clear what series is used as a past or future covariate.
 We recommend [this article](https://medium.com/unit8-machine-learning-publication/time-series-forecasting-using-past-and-future-external-data-with-darts-1f0539585993)
-for more informations and examples.
+for more information and examples.
 
 - 🔴 Significant improvement of `RegressionModel` (incl. `LinearRegressionModel` and `RandomForest`).
 These models now support training on multiple (possibly multivariate) time series. They also support both
@@ -232,7 +241,7 @@ All implementations of `GlobalForecastingModel`s support multivariate time serie
 - Ensemble models, a new kind of `ForecastingModel` which allows to ensemble multiple models to make predictions:
   - `EnsembleModel` is the abstract base class for ensemble models. Classes deriving from `EnsembleModel` must implement the `ensemble()` method, which takes in a `List[TimeSeries]` of predictions from the constituent models, and returns the ensembled prediction (a single `TimeSeries` object)
   - `RegressionEnsembleModel`, a concrete implementation of `EnsembleModel `which allows to specify any regression model (providing `fit()` and `predict()` methods) to use to ensemble the constituent models' predictions.
-- A new method to `TorchForecastingModel`: `untrained_model()` returns the model as it was initally created, allowing to retrain the exact same model from scratch. Works both when specifying a `random_state` or not.
+- A new method to `TorchForecastingModel`: `untrained_model()` returns the model as it was initially created, allowing to retrain the exact same model from scratch. Works both when specifying a `random_state` or not.
 - New `ForecastingModel.backtest()` and `RegressionModel.backtest()` functions which by default compute a single error score from the historical forecasts the model would have produced.
   - A new `reduction` parameter allows to specify whether to compute the mean/median/… of errors or (when `reduction` is set to `None`) to return a list of historical errors.
   - The previous `backtest()` functionality still exists but has been renamed `historical_forecasts()`
@@ -264,7 +273,7 @@ All implementations of `GlobalForecastingModel`s support multivariate time serie
   - Implementing your own data transformers:
     - Data transformers which need to be fitted first should derive from the `FittableDataTransformer` base class and implement a `fit()` method. Fittable transformers also provide a `fit_transform()` method, which fits the transformer and then transforms the data with a single call.
     - Data transformers which perform an invertible transformation should derive from the `InvertibleDataTransformer` base class and implement a `inverse_transform()` method.
-    - Data transformers wich are neither fittable nor invertible should derive from the `BaseDataTransformer` base class
+    - Data transformers which are neither fittable nor invertible should derive from the `BaseDataTransformer` base class
     - All data transformers must implement a `transform()` method.
 - Concrete `DataTransformer` implementations:
   - `MissingValuesFiller` wraps around `fill_missing_value()` and allows to fill missing values using either a constant value or the `pd.interpolate()` method.

README.md

@@ -158,8 +158,8 @@ Some of the models depend on `prophet` and `torch`, which have non-Python depend
 A Conda environment is thus recommended because it will handle all of those in one go.
 
 ### From conda-forge
-Currently only Python 3.7 is fully supported with conda; consider using PyPI if you are running
-into troubles.
+Currently only Linux and macOS on the x86_64 architecture are fully supported with
+conda; consider using PyPI if you are running into troubles.
 
 To create a conda environment for Python 3.7
 (after installing [conda](https://docs.conda.io/en/latest/miniconda.html)):
@@ -225,7 +225,7 @@ To run the tests for specific flavours of the library, replace `_all` with `_cor
 
 ### Documentation
 
-To build documantation locally just run
+To build documentation locally just run
 ```bash
 ./gradlew buildDocs
 ```

darts/models/torch_forecasting_model.py

@@ -217,7 +217,7 @@ def _batch_collate_fn(self, batch: List[Tuple]) -> Tuple:
             elem = first_sample[i]
             if isinstance(elem, np.ndarray):
                 aggregated.append(
-                    torch.from_numpy(np.stack([sample[i] for sample in batch], axis=0)).to(self.device)
+                    torch.from_numpy(np.stack([sample[i] for sample in batch], axis=0))
                 )
             elif elem is None:
                 aggregated.append(None)
@@ -682,7 +682,7 @@ def predict_from_dataset(self,
                                  batch_size=batch_size,
                                  shuffle=False,
                                  num_workers=0,
-                                 pin_memory=False,
+                                 pin_memory=True,
                                  drop_last=False,
                                  collate_fn=self._batch_collate_fn)
         predictions = []
@@ -691,7 +691,7 @@ def predict_from_dataset(self,
         self.model.eval()
         with torch.no_grad():
             for batch_tuple in iterator:
-
+                batch_tuple = self._batch_to_device(batch_tuple)
                 input_data_tuple, batch_input_series = batch_tuple[:-1], batch_tuple[-1]
 
                 # number of individual series to be predicted in current batch
@@ -754,6 +754,10 @@ def _sample_tiling(self, input_data_tuple, batch_sample_size):
                 tiled_input_data.append(None)
         return tuple(tiled_input_data)
 
+    def _batch_to_device(self, batch):
+        batch = [elem.to(self.device) if isinstance(elem, torch.Tensor) else elem for elem in batch]
+        return tuple(batch)
+
     def untrained_model(self):
         return self._load_untrained_model(_get_untrained_models_folder(self.work_dir, self.model_name))
 
@@ -791,6 +795,7 @@ def _train(self,
 
             for batch_idx, train_batch in enumerate(train_loader):
                 self.model.train()
+                train_batch = self._batch_to_device(train_batch)
                 output = self._produce_train_output(train_batch[:-1])
                 target = train_batch[-1]  # By convention target is always the last element returned by datasets
                 loss = self._compute_loss(output, target)

setup_u8darts.py

@@ -29,7 +29,7 @@ def read_requirements(path):
 
 setup(
       name='u8darts',
-      version="0.10.0",
+      version="0.10.1",
       description='A python library for easy manipulation and forecasting of time series.',
       long_description=LONG_DESCRIPTION,
       long_description_content_type="text/markdown",