Implement a NeuralNetRegressor.

Author: ottonemo

README.md

@@ -4,7 +4,7 @@ A scikit-learn compatible neural network library that wraps pytorch.
 
 ## Example
 
-```
+```python
 import numpy as np
 from sklearn.datasets import make_classification
 import torch
@@ -49,7 +49,7 @@ y_proba = net.predict_proba(X)
 
 In an sklearn Pipeline:
 
-```
+```python
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
 
@@ -66,7 +66,7 @@ y_proba = pipe.predict_proba(X)
 
 With grid search
 
-```
+```python
 from sklearn.model_selection import GridSearchCV
 
 

environment.yml

@@ -21,3 +21,5 @@ dependencies:
 - xz=5.2.2=1
 - yaml=0.1.6=0
 - zlib=1.2.8=3
+- pip:
+  - tabulate==0.7.7

inferno/callbacks.py

@@ -1,12 +1,18 @@
+from itertools import cycle
+from numbers import Number
 import operator
+import sys
 import time
 
 import numpy as np
 from sklearn.base import BaseEstimator
 from sklearn import metrics
+from tabulate import tabulate
 
+from inferno.utils import Ansi
 from inferno.utils import to_numpy
 from inferno.utils import to_var
+from inferno.utils import check_history_slice
 
 
 class Callback:
@@ -139,11 +145,87 @@ def on_batch_end(self, net, X, y, train):
         if isinstance(self.scoring, str):  # TODO: make py2.7 compatible
             # scoring is a string
             y = self.target_extractor(y)
-            scorer = getattr(metrics, self.scoring)
+            try:
+                scorer = getattr(metrics, self.scoring)
+            except AttributeError:
+                raise NameError("Metric with name '{}' does not exist, "
+                                "use a valid sklearn metric name."
+                                "".format(self.scoring))
             y_pred = self.pred_extractor(net.module_(to_var(X)))
             score = scorer(y, y_pred)
         else:
             # scoring is a function
             score = self.scoring(net, X, y)
 
         net.history.record_batch(self.name, score)
+
+
+class PrintLog(Callback):
+    def __init__(
+            self,
+            keys=('epoch', 'train_loss', 'valid_loss', 'train_loss_best',
+                  'valid_loss_best', 'dur'),
+            sink=print,
+            tablefmt='simple',
+            floatfmt='.4f',
+    ):
+        self.keys = (keys,) if isinstance(keys, str) else keys
+        self.sink = sink
+        self.tablefmt = tablefmt
+        self.floatfmt = floatfmt
+
+    def initialize(self):
+        self.first_iteration_ = True
+        self.idx_ = {key: i for i, key in enumerate(self.keys)}
+        return self
+
+    def format_row(self, row):
+        row_formatted = []
+        colors = cycle(Ansi)
+
+        for key, item in zip(self.keys, row):
+            if key.endswith('_best'):
+                continue
+
+            if not isinstance(item, Number):
+                row_formatted.append(item)
+                continue
+
+            color = next(colors)
+            # if numeric, there could be a 'best' key
+            idx_best = self.idx_.get(key + '_best')
+
+            is_integer = float(item).is_integer()
+            template = '{}' if is_integer else '{:' + self.floatfmt + '}'
+
+            if (idx_best is not None) and row[idx_best]:
+                template = color.value + template + Ansi.ENDC.value
+            row_formatted.append(template.format(item))
+
+        return row_formatted
+
+    def table(self, data):
+        formatted = [self.format_row(row) for row in data]
+        headers = [key for key in self.keys if not key.endswith('_best')]
+        return tabulate(
+            formatted,
+            headers=headers,
+            tablefmt=self.tablefmt,
+            floatfmt=self.floatfmt,
+        )
+
+    def on_epoch_end(self, net, *args, **kwargs):
+        sl = slice(-1, None), self.keys
+        check_history_slice(net.history, sl)
+        data = net.history[sl]
+        tabulated = self.table(data)
+
+        if self.first_iteration_:
+            header, lines = tabulated.split('\n', 2)[:2]
+            self.sink(header)
+            self.sink(lines)
+            self.first_iteration_ = False
+
+        self.sink(tabulated.rsplit('\n', 1)[-1])
+        if self.sink is print:
+            sys.stdout.flush()

inferno/net.py

@@ -13,7 +13,9 @@
 from inferno.callbacks import BestLoss
 from inferno.callbacks import Callback
 from inferno.callbacks import EpochTimer
+from inferno.callbacks import PrintLog
 from inferno.callbacks import Scoring
+from inferno.utils import get_dim
 from inferno.utils import to_numpy
 from inferno.utils import to_tensor
 from inferno.utils import to_var
@@ -59,15 +61,20 @@ def partial_index(l, idx):
                 return [partial_index(n, idx) for n in l]
 
             # join results of multiple indices
-            if type(idx) is tuple or type(idx) is list:
+            if isinstance(idx, (tuple, list)):
                 def incomplete_mapper(x):
                     for xs in x:
                         if type(xs) is __missingno:
                             return xs
                     return x
-                total_join = zip(*[partial_index(l, n) for n in idx])
-                inner_join = map(incomplete_mapper, total_join)
-                return list(inner_join)
+                zz = [partial_index(l, n) for n in idx]
+                if is_list_like(l):
+                    total_join = zip(*zz)
+                    inner_join = list(map(incomplete_mapper, total_join))
+                else:
+                    total_join = tuple(zz)
+                    inner_join = incomplete_mapper(total_join)
+                return inner_join
 
             try:
                 return l[idx]
@@ -104,6 +111,7 @@ class NeuralNet(Callback):
         ('epoch_timer', EpochTimer),
         ('average_loss', AverageLoss),
         ('best_loss', BestLoss),
+        ('print_log', PrintLog),
     ]
 
     def __init__(
@@ -270,24 +278,23 @@ def fit(self, X, y, **fit_params):
 
         return self
 
-    def predict_proba(self, X):
-        y_proba = self.forward(X, training_behavior=False)
-        y_proba = to_numpy(y_proba)
-        return y_proba
-
     def forward(self, X, training_behavior=False):
         self.module_.train(training_behavior)
 
         iterator = self.get_iterator(X)
-        y_probas = []
+        y_infer = []
         for x in iterator:
             x = to_var(x, use_cuda=self.use_cuda)
-            y_probas.append(self.module_(x))
-        return torch.cat(y_probas, dim=0)
+            y_infer.append(self.module_(x))
+        return torch.cat(y_infer, dim=0)
+
+    def predict_proba(self, X):
+        y_proba = self.forward(X, training_behavior=False)
+        y_proba = to_numpy(y_proba)
+        return y_proba
 
     def predict(self, X):
-        self.module_.train(False)
-        return self.predict_proba(X).argmax(1)
+        return self.predict_proba(X)
 
     def get_optimizer(self):
         kwargs = self._get_params_for('optim')
@@ -378,15 +385,19 @@ class NeuralNetClassifier(NeuralNet):
             ('valid_loss', 'valid_batch_size'),
             ('valid_acc', 'valid_batch_size'),
         ])),
-        ('best_loss', BestLoss(
-            keys_possible=['train_loss', 'valid_loss', 'valid_acc'],
-            signs=[-1, -1, 1],
-        )),
         ('accuracy', Scoring(
             name='valid_acc',
             scoring='accuracy_score',
             pred_extractor=accuracy_pred_extractor,
         )),
+        ('best_loss', BestLoss(
+            keys_possible=['train_loss', 'valid_loss', 'valid_acc'],
+            signs=[-1, -1, 1],
+        )),
+        ('print_log', PrintLog(keys=(
+            'epoch', 'train_loss', 'valid_loss', 'train_loss_best',
+            'valid_loss_best', 'valid_acc', 'valid_acc_best', 'dur'),
+        )),
     ]
 
     def __init__(
@@ -406,3 +417,29 @@ def __init__(
     def get_loss(self, y_pred, y, train=False):
         y_pred_log = torch.log(y_pred)
         return self.criterion_(y_pred_log, y)
+
+    def predict(self, X):
+        return self.predict_proba(X).argmax(1)
+
+
+class NeuralNetRegressor(NeuralNet):
+    def __init__(
+            self,
+            module,
+            criterion=torch.nn.MSELoss,
+            *args,
+            **kwargs
+    ):
+        super(NeuralNetRegressor, self).__init__(
+            module,
+            criterion=criterion,
+            *args,
+            **kwargs
+        )
+
+    def check_data(self, _, y):
+        # The problem with 1-dim float y is that the pytorch DataLoader will
+        # somehow upcast it to DoubleTensor
+        if get_dim(y) == 1:
+            raise ValueError("The target data shouldn't be 1-dimensional; "
+                             "please reshape (e.g. y.reshape(-1, 1).")

inferno/tests/conftest.py

@@ -0,0 +1,48 @@
+from unittest.mock import Mock
+
+import pytest
+
+
+@pytest.fixture
+def history_cls():
+    from inferno.net import History
+    return History
+
+
+@pytest.fixture
+def history(history_cls):
+    return history_cls()
+
+
+def get_history(*callbacks, history_cls=history_cls):
+    h = history_cls()()
+    net = Mock()
+    net.history = h
+    data = [(range(6, 10), 1, 'hi'),
+            (range(2, 6), 2, 'ho'),
+            (range(10, 14), 3, 'hu')]
+
+    for range_, epoch, text in data:
+        h.new_epoch()
+        for cb in callbacks:
+            cb.on_epoch_begin(net)
+
+        for i in range_:
+            h.new_batch()
+            for cb in callbacks:
+                cb.on_batch_begin(net)
+
+            h.record_batch('train_loss', 1 - i / 10)
+            h.record_batch('train_batch_size', 10)
+            h.record_batch('valid_loss', i)
+            h.record_batch('valid_batch_size', 1)
+
+            for cb in callbacks:
+                cb.on_batch_end(net)
+
+        h.record('epoch', epoch)
+        h.record('text', text)
+        for cb in callbacks:
+            cb.on_epoch_end(net)
+
+    return h