Suggestions for project

.gitignore

@@ -7,6 +7,7 @@ build
 
 # Dataset
 *.npz
+datasets/*.csv
 
 # Models
 *.pth
@@ -24,3 +25,6 @@ _build
 # Figures
 *.png
 *.jpg
+
+# Outputs
+*.csv

.pylintrc

@@ -0,0 +1,9 @@
+[MASTER]
+extension-pkg-whitelist=numpy,torch
+
+[TYPECHECK]
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=numpy.*,torch.*

README.md

@@ -1,28 +1,33 @@
-[![Documentation Status](https://readthedocs.org/projects/timeseriestransformer/badge/?version=latest)](https://timeseriestransformer.readthedocs.io/en/latest/?badge=latest) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![Latest release](https://img.shields.io/github/release/maxjcohen/transformer.svg)](https://github.com/maxjcohen/transformer/releases/latest)
+# Transformers for Time Series
 
-Transformers for Time Series
-============================
+[![Documentation Status](https://readthedocs.org/projects/timeseriestransformer/badge/?version=latest)](https://timeseriestransformer.readthedocs.io/en/latest/?badge=latest) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![Latest release](https://img.shields.io/github/release/maxjcohen/transformer.svg)](https://github.com/maxjcohen/transformer/releases/latest)
 
 Implementation of Transformer model (originally from [Attention is All You Need](https://arxiv.org/abs/1706.03762)) applied to Time Series (Powered by [PyTorch](https://pytorch.org/)).
 
 ## Transformer model
+
 Transformer are attention based neural networks designed to solve NLP tasks. Their key features are:
+
 - linear complexity in the dimension of the feature vector ;
 - paralellisation of computing of a sequence, as opposed to sequential computing ;
 - long term memory, as we can look at any input time sequence step directly.
 
 This repo will focus on their application to times series.
 
 ## Dataset and application as metamodel
+
 Our use-case is modeling a numerical simulator for building consumption prediction. To this end, we created a dataset by sampling random inputs (building characteristics and usage, weather, ...) and got simulated outputs. We then convert these variables in time series format, and feed it to the transformer.
 
 ## Adaptations for time series
+
 In order to perform well on time series, a few adjustments had to be made:
+
 - The embedding layer is replaced by a generic linear layer ;
 - Original positional encoding are removed. A "regular" version, better matching the input sequence day/night patterns, can be used instead ;
 - A window is applied on the attention map to limit backward attention, and focus on short term patterns.
 
 ## Installation
+
 All required packages can be found in `requirements.txt`, and expect to be run with `python3.7`. Note that you may have to install pytorch manually if you are not using pip with a Debian distribution : head on to [PyTorch installation page](https://pytorch.org/get-started/locally/). Here are a few lines to get started with pip and virtualenv:
 
 ```bash
@@ -36,12 +41,15 @@ $ . .env/bin/activate
 ## Usage
 
 ### Downloading the dataset
+
 The dataset is not included in this repo, and must be downloaded manually. It is comprised of two files, `dataset.npz` contains all input and outputs value, `labels.json` is a detailed list of the variables.
 
 ### Running training script
-Using jupyter, run the default `training.ipynb` notebook. All adjustable parameters can be found in the second cell. Careful with the `BATCH_SIZE`, as we are using it to parallelize head and time chunk calculations. 
+
+Using jupyter, run the default `training.ipynb` notebook. All adjustable parameters can be found in the second cell. Careful with the `BATCH_SIZE`, as we are using it to parallelize head and time chunk calculations.
 
 ### Outside usage
+
 The `Transformer` class can be used out of the box, [docs](https://timeseriestransformer.readthedocs.io/en/latest/Transformer.html) for more info.
 
 ```python
@@ -51,7 +59,9 @@ net = Transformer(d_input, d_model, d_output, q, v, h, N, TIME_CHUNK, pe)
 ```
 
 ### Building the docs
+
 To build the doc:
+
 ```bash
 (.env) $ cd docs && make html
 ```

benchmark.ipynb

@@ -24,7 +24,7 @@
     "from tqdm import tqdm\n",
     "import seaborn as sns\n",
     "\n",
-    "from tst.loss import OZELoss\n",
+    "from test.loss import OZELoss\n",
     "\n",
     "from src.benchmark import BiGRU, ConvGru\n",
     "from src.dataset import OzeDataset\n",
@@ -395,4 +395,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}

cross_validation.py

@@ -1,15 +1,17 @@
-import numpy as np
+"""
+Cross validation
+"""
+# import numpy as np
 import torch
-import torch.nn as nn
+# import torch.nn as nn
 import torch.optim as optim
 from tqdm import tqdm
 
-from tst import Transformer
-from tst.loss import OZELoss
-
+from src.benchmark import BiGRU  # , LSTM
 from src.dataset import OzeDataset
-from src.utils import compute_loss, fit, Logger, kfold
-from src.benchmark import LSTM, BiGRU
+from src.utils import Logger, fit, kfold  # compute_loss
+# from test import Transformer
+from tst.loss import OZELoss
 
 # Search parameters
 CHUNKS = 5
@@ -58,7 +60,8 @@
         # Load transformer with Adam optimizer and MSE loss function
         # net = Transformer(d_input, d_model, d_output, q, v, h, N, attention_size=attention_size,
         #                   dropout=dropout, chunk_mode=chunk_mode, pe=pe).to(device)
-        net = BiGRU(d_input, d_model, d_output, num_layers=N, dropout=dropout, bidirectional=True).to(device)
+        net = BiGRU(d_input, d_model, d_output, num_layers=N, dropout=dropout, \
+            bidirectional=True).to(device)
 
         optimizer = optim.Adam(net.parameters(), lr=LR)
 

datasets/README.md

@@ -0,0 +1,9 @@
+# Datasets
+
+## Description
+
+This is the folder where datasets should be downloaded to.
+
+## Installation
+
+After downloading the .csv files from the [challenge](https://challengedata.ens.fr/challenges/28), install by running `make_npz.py`

export_doc.py

@@ -1,9 +1,12 @@
+"""
+Export doc
+"""
 import json
 import datetime
 from pathlib import Path
 import argparse
 
-
+# NOTE Redefining name 'notebook_path' from outer scope (line 39)pylint(redefined-outer-name)
 def export_notebook(notebook_path: Path, export_dir: Path):
     # Load notebook
     with open(notebook_path, "r") as stream_json:
@@ -18,6 +21,7 @@ def export_notebook(notebook_path: Path, export_dir: Path):
 
     # Add date to export path
     export_name = f'training_{export_time.strftime("%Y_%m_%d__%H%M%S")}.ipynb'
+    # NOTE Redefining name 'export_path' from outer scope (line 40)pylint(redefined-outer-name)
     export_path = export_dir.joinpath(export_name)
 
     # Export

learning_curve.py

@@ -1,18 +1,16 @@
-import numpy as np
-from matplotlib import pyplot as plt
+"""
+Learning curve
+"""
+import seaborn as sns
 import torch
-import torch.nn as nn
 import torch.optim as optim
 from tqdm import tqdm
-import seaborn as sns
 
+from src.dataset import OzeDataset
+from src.utils import Logger, fit, learning_curve
 from tst import Transformer
 from tst.loss import OZELoss
 
-from src.dataset import OzeDataset
-from src.utils import visual_sample, compute_loss
-from src.utils import compute_loss, fit, Logger, kfold, leargnin_curve
-
 # Search parameters
 PARTS = 8
 VALIDATION_SPLIT = 0.3
@@ -53,11 +51,11 @@
 
 logger = Logger('learningcurve_log.csv')
 
-learningcurveIterator = leargnin_curve(ozeDataset, n_part=PARTS, validation_split=VALIDATION_SPLIT,
-                      batch_size=BATCH_SIZE, num_workers=NUM_WORKERS)
+learning_curve_iterator = learning_curve(ozeDataset, n_part=PARTS, \
+    validation_split=VALIDATION_SPLIT, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS)
 
 with tqdm(total=PARTS*EPOCHS) as pbar:
-    for dataloader_train, dataloader_val in learningcurveIterator:
+    for dataloader_train, dataloader_val in learning_curve_iterator:
 
         # Load transformer with Adam optimizer and MSE loss function
         net = Transformer(d_input, d_model, d_output, q, v, h, N, attention_size=attention_size,
@@ -70,4 +68,4 @@
                    dataloader_val, epochs=EPOCHS, pbar=pbar, device=device)
 
         # Log
-        logger.log(loss=loss)
+        logger.log(loss=loss)

requirements.txt

@@ -2,4 +2,5 @@ torch
 jupyterlab
 matplotlib
 seaborn
-tqdm
+tqdm
+pylint

search.py

@@ -1,21 +1,20 @@
+"""
+Search
+"""
 import itertools
-import datetime
-import json
 from collections import OrderedDict
 
 import numpy as np
 import torch
-import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader, random_split
 from tqdm import tqdm
 
+from src.dataset import OzeDataset
+from src.utils import Logger, fit
 from tst import Transformer
 from tst.loss import OZELoss
 
-from src.dataset import OzeDataset
-from src.utils import compute_loss, fit, Logger
-
 # ===== user set params ====
 search_params = OrderedDict({
     "d_model": [32],

setup.py

@@ -1,3 +1,6 @@
+"""
+Setup
+"""
 import setuptools
 
 with open("README.md", "r") as fh:

src/benchmark.py

@@ -1,3 +1,6 @@
+"""
+Benchmark
+"""
 import torch
 import torch.nn as nn
 
@@ -21,6 +24,7 @@ class LSTM(nn.Module):
         If ``True``, becomes a bidirectional LSTM. Default: ``False``.
     """
 
+    # NOTE Too many arguments (7/5)pylint(too-many-arguments)
     def __init__(self,
                  input_dim: int,
                  hidden_dim: int,
@@ -31,12 +35,14 @@ def __init__(self,
                  **kwargs):
         super().__init__(**kwargs)
 
-        self.rnn = nn.LSTM(input_dim, hidden_dim, num_layers=num_layers, dropout=dropout, batch_first=True, bidirectional=bidirectional)
+        self.rnn = nn.LSTM(input_dim, hidden_dim, num_layers=num_layers, dropout=dropout, \
+            batch_first=True, bidirectional=bidirectional)
 
         if bidirectional:
             hidden_dim *= 2
         self.linear = nn.Linear(hidden_dim, output_dim)
 
+    # NOTE Parameters differ from overridden 'forward' methodpylint(arguments-differ)
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         """Propagate input through the network.
 
@@ -81,12 +87,18 @@ def __init__(self,
                  dropout: float = 0,
                  bidirectional: bool = False,
                  **kwargs):
-        super().__init__(input_dim, hidden_dim, output_dim, num_layers, dropout, bidirectional, **kwargs)
+        super().__init__(input_dim, hidden_dim, output_dim, num_layers, dropout, bidirectional, \
+            **kwargs)
 
-        self.rnn = nn.GRU(input_dim, hidden_dim, num_layers=num_layers, dropout=dropout, batch_first=True, bidirectional=bidirectional)
+        self.rnn = nn.GRU(input_dim, hidden_dim, num_layers=num_layers, dropout=dropout, \
+            batch_first=True, bidirectional=bidirectional)
 
 
 class ConvGru(nn.Module):
+    """
+    ConvGru
+    """
+    # NOTE Too many arguments (7/5)pylint(too-many-arguments)
     def __init__(self,
                  input_dim: int,
                  hidden_dim: int,
@@ -97,9 +109,12 @@ def __init__(self,
                  **kwargs):
         super().__init__(**kwargs)
 
-        self.conv1 = nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, kernel_size=11, stride=1, padding=11//2)
-        self.conv2 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=11, stride=1, padding=11//2)
-        self.conv3 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=11, stride=1, padding=11//2)
+        self.conv1 = nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, \
+            kernel_size=11, stride=1, padding=11//2)
+        self.conv2 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, \
+            kernel_size=11, stride=1, padding=11//2)
+        self.conv3 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, \
+            kernel_size=11, stride=1, padding=11//2)
 
         self.activation = nn.LeakyReLU(0.1)
 
@@ -110,6 +125,7 @@ def __init__(self,
                          dropout=dropout,
                          bidirectional=bidirectional)
 
+    # NOTE Parameters differ from overridden 'forward' methodpylint(arguments-differ)
     def forward(self, x):
         x = x.transpose(1, 2)
         x = self.conv1(x)
@@ -126,20 +142,28 @@ def forward(self, x):
 
 
 class FullyConv(nn.Module):
+    """
+    FullyConv
+    """
     def __init__(self,
                  input_dim: int,
                  hidden_dim: int,
                  output_dim: int,
+                 # NOTE Unused argument 'dropout'pylint(unused-argument)
                  dropout: float = 0,
                  **kwargs):
         super().__init__(**kwargs)
 
-        self.conv1 = nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, kernel_size=11, stride=1, padding=11//2)
-        self.conv2 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=11, stride=1, padding=11//2)
-        self.conv3 = nn.Conv1d(in_channels=hidden_dim, out_channels=output_dim, kernel_size=11, stride=1, padding=11//2)
+        self.conv1 = nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, \
+            kernel_size=11, stride=1, padding=11//2)
+        self.conv2 = nn.Conv1d(in_channels=hidden_dim, out_channels=hidden_dim, \
+            kernel_size=11, stride=1, padding=11//2)
+        self.conv3 = nn.Conv1d(in_channels=hidden_dim, out_channels=output_dim, \
+            kernel_size=11, stride=1, padding=11//2)
 
         self.activation = nn.LeakyReLU(0.1)
 
+    # NOTE Parameters differ from overridden 'forward' methodpylint(arguments-differ)
     def forward(self, x):
         x = x.transpose(1, 2)
         x = self.conv1(x)

src/dataset.py

@@ -1,3 +1,6 @@
+"""
+Dataset
+"""
 import json
 from typing import Optional
 
@@ -103,7 +106,8 @@ def rescale(self,
             Index of the output label.
         """
         if self._normalize == "max":
-            return y * (self._M[idx_label] - self._m[idx_label] + np.finfo(float).eps) + self._m[idx_label]
+            return y * (self._M[idx_label] - self._m[idx_label] + np.finfo(float).eps) + \
+                self._m[idx_label]
         elif self._normalize == "mean":
             return y * (self._std[idx_label] + np.finfo(float).eps) + self._mean[idx_label]
         else:

src/utils/__init__.py

@@ -1,2 +1,5 @@
-from .search import Logger, fit, kfold, leargnin_curve
-from .utils import compute_loss
+"""
+__init__.py
+"""
+from .search import Logger, fit, kfold, learning_curve
+from .utils import compute_loss