talos 1.4__py2.py3-none-any.whl

talos/__init__.py

@@ -0,0 +1,38 @@
+import warnings
+warnings.simplefilter('ignore')
+
+# import commands
+from .scan.Scan import Scan
+from .commands.analyze import Analyze
+from .commands.analyze import Analyze as Reporting
+from .commands.predict import Predict
+from .commands.deploy import Deploy
+from .commands.evaluate import Evaluate
+from .commands.restore import Restore
+
+# import extras
+from . import utils
+from . import templates
+from . import autom8
+from . import callbacks
+
+# the purpose of everything below is to keep the namespace completely clean
+
+template_sub = [templates.datasets,
+                templates.models,
+                templates.params,
+                templates.pipelines]
+
+keep_from_templates = ['iris', 'cervical_cancer', 'titanic', 'breast_cancer',
+                       'icu_mortality', 'telco_churn', 'mnist']
+
+for sub in template_sub:
+    for key in list(sub.__dict__):
+        if key.startswith('__') is False:
+            if key not in keep_from_templates:
+                delattr(sub, key)
+
+del commands, scan, model, metrics, key
+del sub, keep_from_templates, template_sub, warnings
+
+__version__ = "1.4"

talos/autom8/__init__.py

@@ -0,0 +1,6 @@
+from .automodel import AutoModel
+from .autoparams import AutoParams
+from .autopredict import AutoPredict
+from .autoscan import AutoScan
+
+del automodel, autoparams, autopredict, autoscan

talos/autom8/automodel.py

@@ -0,0 +1,126 @@
+class AutoModel:
+
+    def __init__(self, task, experiment_name, metric=None):
+
+        '''
+
+        Creates an input model for Scan(). Optimized for being used together
+        with Params(). For example:
+
+        p = talos.AutoParams().params
+        model = talos.AutoModel(task='binary').model
+
+        talos.Scan(x, y, p, model)
+
+        NOTE: the parameter space from Params() is very large, so use limits
+        in or reducers in Scan() accordingly.
+
+        task : string or None
+            If 'continuous' then mae is used for metric, if 'binary',
+            'multiclass', or 'multilabel', f1score is used. Accuracy is always
+            used.
+        experiment_name | str | Must be same as in `Scan()`
+        metric : None or list
+            You can also input a list with one or more custom metrics or names
+            of Keras or Talos metrics.
+        '''
+
+        from talos.callbacks.experiment_log import ExperimentLog
+
+        self.task = task
+        self.experiment_name = experiment_name
+        self.metric = metric
+
+        if self.task is not None:
+            self.metrics = self._set_metric()
+        elif self.metric is not None and isinstance(self.metric, list):
+            self.metrics = self.metric + ['acc']
+        else:
+            print("Either pick task or provide list as input for metric.")
+
+        # create the model
+        self.model = self._create_input_model
+        self.callback = ExperimentLog
+
+    def _set_metric(self):
+
+        """Sets the metric for the model based on the experiment type
+        or a list of metrics from user."""
+
+        import talos as ta
+
+        if self.task in ['binary', 'multiclass', 'multilabel']:
+            return [ta.utils.metrics.f1score, 'acc']
+        elif self.task == 'continuous':
+            return [ta.utils.metrics.mae, 'acc']
+
+    def _create_input_model(self, x_train, y_train, x_val, y_val, params):
+
+        import wrangle as wr
+
+        from tensorflow.keras.models import Sequential
+        from tensorflow.keras.layers import Dropout, Flatten
+        from tensorflow.keras.layers import LSTM, Conv1D, SimpleRNN, Dense, Bidirectional
+
+        model = Sequential()
+
+        if params['network'] != 'dense':
+            x_train = wr.array_reshape_conv1d(x_train)
+            x_val = wr.array_reshape_conv1d(x_val)
+
+        if params['network'] == 'conv1d':
+            model.add(Conv1D(params['first_neuron'], x_train.shape[1]))
+            model.add(Flatten())
+
+        elif params['network'] == 'lstm':
+            model.add(LSTM(params['first_neuron']))
+
+        if params['network'] == 'bidirectional_lstm':
+            model.add(Bidirectional(LSTM(params['first_neuron'])))
+
+        elif params['network'] == 'simplernn':
+            model.add(SimpleRNN(params['first_neuron']))
+
+        elif params['network'] == 'dense':
+            model.add(Dense(params['first_neuron'],
+                            input_dim=x_train.shape[1],
+                            activation='relu',
+                            kernel_initializer=params['kernel_initializer']))
+
+        model.add(Dropout(params['dropout']))
+
+        # add hidden layers to the model
+        from talos.model.hidden_layers import hidden_layers
+        hidden_layers(model, params, 1)
+
+        # get the right activation and last_neuron based on task
+        from talos.model.output_layer import output_layer
+        activation, last_neuron = output_layer(self.task,
+                                               params['last_activation'],
+                                               y_train,
+                                               y_val)
+
+        model.add(Dense(last_neuron,
+                        activation=activation,
+                        kernel_initializer=params['kernel_initializer']))
+
+        # bundle the optimizer with learning rate changes
+        from talos.model.normalizers import lr_normalizer
+        optimizer = params['optimizer'](lr=lr_normalizer(params['lr'],
+                                                         params['optimizer']))
+
+        # compile the model
+        model.compile(optimizer=optimizer,
+                      loss=params['losses'],
+                      metrics=self.metrics)
+
+        # fit the model
+        out = model.fit(x_train, y_train,
+                        batch_size=params['batch_size'],
+                        epochs=params['epochs'],
+                        verbose=0,
+                        callbacks=[self.callback(self.experiment_name, params)],
+                        validation_data=(x_val, y_val))
+
+        # pass the output to Talos
+        return out, model

talos/autom8/autoparams.py

@@ -0,0 +1,272 @@
+import numpy as np
+from tensorflow.keras.optimizers.legacy import Adam, Adagrad, SGD
+
+
+loss = {'binary': ['binary_crossentropy', 'LogCosh'],
+        'multi_class': ['sparse_categorical_crossentropy'],
+        'multi_label': ['categorical_crossentropy'],
+        'continuous': ['mae']}
+
+last_activation = {'binary': ['sigmoid'],
+                   'multi_class': ['softmax'],
+                   'multi_label': ['softmax'],
+                   'continuous': [None]}
+
+
+class AutoParams:
+
+    def __init__(self,
+                 params=None,
+                 task='binary',
+                 replace=True,
+                 auto=True,
+                 network=True,
+                 resample_params=4):
+
+        '''A facility for generating or appending params dictionary.
+
+        params : dict or None
+        task : str
+             'binary', 'multi_class', 'multi_label', or 'continuous'
+        replace : bool
+             Replace current dictionary entries with new ones.
+        auto : bool
+             Automatically generate or append params dictionary with
+             all available parameters.
+        network : bool
+             Adds several network architectures as parameters. This is to be
+             used as an input together with KerasModel(). If False then only
+             'dense' will be added.
+        resample_params | int or False | The number of values per parameter
+        '''
+
+        self._task = task
+        self._replace = replace
+        self._network = network
+
+        if params is None:
+            self.params = {}
+        else:
+            self.params = params
+        if auto:
+            self._automated()
+
+        if resample_params is not False:
+            self.resample_params(resample_params)
+
+    def _automated(self, shapes='fixed'):
+
+        '''Automatically generate a comprehensive
+        parameter dict to be used in Scan()
+
+        shapes : string
+            Either 'fixed' or 'sloped'
+
+        '''
+
+        if shapes == 'fixed':
+            self.shapes()
+        else:
+            self.shapes_slope()
+        self.layers()
+        self.dropout()
+        self.optimizers()
+        self.activations()
+        self.neurons()
+        self.losses()
+        self.batch_size()
+        self.epochs()
+        self.kernel_initializers()
+        self.lr()
+        if self._network:
+            self.networks()
+        else:
+            self.params['network'] = ['dense']
+        self.last_activations()
+
+    def shapes(self, shapes='auto'):
+
+        '''Uses triangle, funnel, and brick shapes.'''
+
+        if shapes == 'auto':
+            self._append_params('shapes', ['triangle', 'funnel', 'brick'])
+        else:
+            self._append_params('shapes', shapes)
+
+    def shapes_slope(self, min_slope=0, max_slope=.6, steps=.1):
+
+        '''Uses a single decimal float for values below 0.5 to
+        reduce the width of the following layer.'''
+
+        self._append_params('shapes', np.arange(min_slope,
+                                                max_slope,
+                                                steps).tolist())
+
+    def layers(self, min_layers=0, max_layers=6, steps=1):
+
+        self._append_params('hidden_layers',
+                            list(range(min_layers, max_layers, steps)))
+
+    def dropout(self, min_dropout=0, max_dropout=.85, steps=0.1):
+
+        self._append_params('dropout',
+                            np.round(np.arange(min_dropout,
+                                               max_dropout,
+                                               steps), 2).tolist())
+
+    def optimizers(self, optimizers='auto'):
+
+        '''If `optimizers='auto'` then optimizers will be picked based on
+        automatically. Otherwise input a list with one or
+        more optimizers will be used.
+        '''
+
+        if optimizers == 'auto':
+            self._append_params('optimizer', [Adam, Adagrad, SGD])
+        else:
+            self._append_params('optimizer', optimizers)
+
+    def activations(self, activations='auto'):
+
+        '''If `activations='auto'` then activations will be picked based on
+        automatically. Otherwise input a list with one or
+        more activations will be used.
+        '''
+
+        if activations == 'auto':
+            activations = ['relu', 'elu']
+
+        self._append_params('activation', activations)
+
+    def losses(self, losses='auto'):
+
+        '''If `losses='auto'` then losses will be picked based on
+        `AutoParam()` argument `task`. Otherwise input a list with one or
+        more losses will be used.
+        '''
+
+        if losses == 'auto':
+            self._append_params('losses', loss[self._task])
+        else:
+            self._append_params('losses', losses)
+
+    def neurons(self, min_neuron=8, max_neuron=None, steps=None):
+
+        '''`max` and `steps` has to be either `None` or
+        integer value at the same time.'''
+
+        if max_neuron is None and steps is None:
+            values = [int(np.exp2(i)) for i in range(3, 11)]
+        else:
+            values = list(range(min_neuron, max_neuron, steps))
+
+        self._append_params('first_neuron', values)
+
+    def batch_size(self, min_size=8, max_size=None, steps=None):
+
+        '''`max_size` and `steps` has to be either `None` or
+        integer value at the same time.'''
+
+        if max_size is None and steps is None:
+            values = [int(np.exp2(i / 2)) for i in range(3, 15)]
+        else:
+            values = list(range(min_size, max_size, steps))
+
+        self._append_params('batch_size', values)
+
+    def epochs(self, min_epochs=50, max_epochs=None, steps=None):
+
+        '''`max_epochs` and `steps` has to be either `None` or
+        integer value at the same time.'''
+
+        if max_epochs is None and steps is None:
+            values = [int(np.exp2(i / 2)) + 50 for i in range(3, 15)]
+        else:
+            values = list(range(min_epochs, max_epochs, steps))
+
+        self._append_params('epochs', values)
+
+    def kernel_initializers(self, kernel_inits='auto'):
+
+        '''
+        kernel_inits | list | one or more kernel initializers
+        '''
+
+        if kernel_inits == 'auto':
+            self._append_params('kernel_initializer',
+                                ['uniform', 'normal', 'he_normal',
+                                 'he_uniform', 'lecun_normal',
+                                 'glorot_uniform', 'glorot_normal',
+                                 'random_uniform', 'random_normal'])
+        else:
+            self._append_params('kernel_initializer', kernel_inits)
+
+    def lr(self, learning_rates='auto'):
+
+        '''If `learning_rates='auto'` then a very wide range of learning rates
+        will be added. Otherwise a list with one or more learning rates
+        is used.
+
+        NOTE: talos.utils.lr_normalizer should be used if more than one optimizer
+        is used in the experiment
+        '''
+
+        if learning_rates == 'auto':
+
+            a = np.round(np.arange(0.01, 0.2, 0.02), 3).tolist()
+            b = np.round(np.arange(0, 1, 0.2), 2).tolist()
+            c = list(range(0, 11))
+
+            self._append_params('lr', a + b + c)
+
+        else:
+
+            self._append_params('lr', learning_rates)
+
+    def networks(self, networks='auto'):
+
+        '''If `network='auto'` then dense, simplernn, lstm, conv1d, and
+        bidirectional_lstm are added. Otherwise a list with one or more
+        network architectures is used.
+        '''
+
+        if networks == 'auto':
+            self._append_params('network', ['dense',
+                                            'simplernn',
+                                            'lstm',
+                                            'bidirectional_lstm',
+                                            'conv1d'])
+        else:
+            self._append_params('network', networks)
+
+    def last_activations(self, last_activations='auto'):
+
+        '''If `last_activations='auto'` then activations will be picked
+        automatically based on `AutoParams` property `task`.
+        Otherwise input a list with one or more activations will be used.
+        '''
+
+        if last_activations == 'auto':
+            self._append_params('last_activation', last_activation[self._task])
+        else:
+            self._append_params('last_activation', last_activations)
+
+    def resample_params(self, n):
+
+        '''Resamples params dictionary so that `n` values are present for each
+        parameter.'''
+
+        from wrangle import dic_resample_values
+
+        self.params = dic_resample_values(self.params, n)
+
+    def _append_params(self, label, values):
+
+        if self._replace is False:
+            try:
+                self.params[label]
+            except KeyError:
+                self.params[label] = values
+
+        else:
+            self.params[label] = values

talos/autom8/autopredict.py

@@ -0,0 +1,108 @@
+def AutoPredict(scan_object,
+                x_val,
+                y_val,
+                x_pred,
+                task,
+                metric='val_acc',
+                n_models=10,
+                folds=5,
+                shuffle=True,
+                asc=False):
+
+    '''Automatically handles the process of finding the best models from a
+    completed `Scan()` experiment, evaluates those models, and uses the winner
+    to make predictions on input data.
+
+    NOTE: the input data must be in same format as 'x' that was
+    used in `Scan()`.
+
+    Parameters
+    ----------
+    scan_object : Scan() object
+        A Scan() process needs to be completed first, and then the resulting
+        object can be used as input here.
+    x_val : ndarray or list of ndarray
+        Data to be used for 'x' in evaluation. Note that should be in the same
+        format as the data which was used in the Scan() but not the same data.
+    y_val : ndarray or list of ndarray
+        Data to be used for 'y' in evaluation. Note that should be in the same
+        format as the data which was used in the Scan() but not the same data.
+    y_pred : ndarray or list of ndarray
+        Input data to be used for the actual predictions in evaluation. Note
+        it should be in the same format as the data which was used in the
+        Scan() but not the same data.
+    task : string
+        'binary', 'multi_class', 'multi_label', or 'continuous'.
+    metric : str
+        The metric to be used for deciding which models are promising.
+        Basically the 'n' argument and 'metric' argument are combined to pick
+        'n' best performing models based on 'metric'.
+    n_models : str
+        Number of promising models to be included in the evaluation process.
+        Time increase linearly with number of models.
+    folds : int
+        Number of folds to be used in cross-validation.
+    shuffle : bool
+        If the data should be shuffled before cross-validation.
+    average : str
+        This parameter is required for multiclass/multilabel targets. If None,
+        the scores for each class are returned. Otherwise, this determines
+        the type of averaging performed on the data:
+
+        'binary':
+        Only report results for the class specified by pos_label.
+        This is applicable only if targets (y_{true,pred}) are binary.
+
+        'micro':
+        Calculate metrics globally by counting the total true positives,
+        false negatives and false positives.
+
+        'macro':
+        Calculate metrics for each label, and find their unweighted mean.
+        This does not take label imbalance into account.
+
+        'weighted':
+        Calculate metrics for each label, and find their average weighted
+        by support (the number of true instances for each label). This alters
+        'macro' to account for label imbalance; it can result in an F-score
+        that is not between precision and recall.
+
+        'samples':
+        Calculate metrics for each instance, and find their average
+        (only meaningful for multilabel classification where this differs
+        from accuracy_score).
+    asc : bool
+        This needs to be True for evaluation metrics that need to be minimized,
+        and False when a metric needs to be maximized.
+
+    '''
+
+    import numpy as np
+
+    # evaluate and add the evaluation scores
+    scan_object.evaluate_models(x_val,
+                                y_val,
+                                n_models=n_models,
+                                task=task,
+                                metric=metric,
+                                folds=folds,
+                                shuffle=shuffle,
+                                asc=False)
+
+    # get the best model based on evaluated score
+    scan_object.preds_model = scan_object.best_model('eval_f1score_mean')
+
+    # make predictions with the model
+    scan_object.preds_probabilities = scan_object.preds_model.predict(x_pred)
+
+    # make (class) predictiosn with the model
+    preds = scan_object.preds_model.predict(x_pred)   
+    scan_object.preds_classes = np.argmax(preds, axis=1)
+
+    # get the hyperparameter for the model
+    scan_object.preds_parameters = scan_object.data.sort_values('eval_f1score_mean',
+                                                           ascending=False).iloc[0]
+
+    print(">> Added model, probabilities, classes, and parameters to scan_object")
+
+    return scan_object

talos/autom8/autoscan.py

@@ -0,0 +1,56 @@
+class AutoScan:
+
+    def __init__(self,
+                 task,
+                 experiment_name,
+                 max_param_values=None):
+
+        '''Configure the `AutoScan()` experiment and then use
+        the property `start` in the returned class object to start
+        the actual experiment.
+
+        `task` | str | 'binary', 'multi_class', 'multi_label', or 'continuous'
+        `max_param_values` | int | Number of parameter values to be included.
+                                   Note, this will only work when `params` is
+                                   not passed as kwargs in `AutoScan.start`.
+        '''
+
+        self.task = task
+        self.max_param_values = max_param_values
+        self.experiment_name = experiment_name
+
+    def start(self, x, y, **kwargs):
+
+        '''Start the scan. Note that you can use `Scan()` arguments as you
+        would otherwise directly interacting with `Scan()`.
+
+        `x` | array or list of arrays | prediction features
+        `y` | array or list of arrays | prediction outcome variable
+        `kwargs` | arguments | any `Scan()` argument can be passed here
+
+        '''
+
+        import talos
+
+        m = talos.autom8.AutoModel(self.task, self.experiment_name).model
+
+        try:
+            kwargs['params']
+            scan_object = talos.Scan(x, y,
+                                     model=m,
+                                     experiment_name=self.experiment_name,
+                                     **kwargs)
+        except KeyError:
+            p = talos.autom8.AutoParams(task=self.task)
+
+            if self.max_param_values is not None:
+                p.resample_params(self.max_param_values)
+            params = p.params
+            scan_object = talos.Scan(x=x,
+                                     y=y,
+                                     params=params,
+                                     model=m,
+                                     experiment_name=self.experiment_name,
+                                     **kwargs)
+
+        return scan_object

talos/callbacks/__init__.py

@@ -0,0 +1,5 @@
+from kerasplotlib import TrainingLog as TrainingPlot
+from .experiment_log import ExperimentLog
+from .power_draw import PowerDraw
+
+del experiment_log, power_draw