## Hyperparameter Scanning and Optimization for Keras

Talos is a solution that helps finding hyperparameter configurations for Keras models. To perform hyperparameter optimization with Talos, there is no need to learn any new syntax, or change anything in the way Keras models are created. Keras functionality is fully exposed, and any parameter can be included in the scans.

### brief | concise | comprehensive example Notebook

See a### User Manual

Read the### Report on Hyperparameter Optimization with Keras

Read a### Roadmap

Read the`pip install talos`

Install
### Is Talos for Me?

Talos is made for data scientists and data engineers that want to remain in complete control of their Keras models, but are tired of mindless parameter hopping and confusing optimization solutions that add complexity instead of reducing it. Within minutes, without learning any new syntax, Talos allows you to configure, perform, and evaluate hyperparameter optimization experiments that yield state-of-the-art (e.g. Iris dataset 100% and Wisconsin Breast Cancer dataset 99.4%) across a range of prediction tasks, by providing the simplest available method for hyperparameter optimization with Keras.

## Benefits

Based on a review of more than 30 hyperparameter optimization and scanning solutions, Talos offers the most intuitive, easy-to-learn, and permissive access to important hyperparameter optimization capabilities.

- works with ANY Keras model
- very easy to implement
- adds zero new overhead
- provides several ways to reduce random-search complexity
- no need to learn any new syntax
- no blackbox / other statistical complexity
- improved f1 performance metric for binary, multi-label, multi-class and continuous predictions

## Install

Production version:

```
pip install talos
```

Latest development version

```
pip install git+https://github.com/autonomio/talos.git@daily-dev
```

## How to use

Let's consider an example of a simple Keras model:

```
model = Sequential()
model.add(Dense(8, input_dim=x_train.shape[1], activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(y_train.shape[1], activation='softmax'))
model.compile(optimizer='adam',
loss=categorical_crossentropy,
metrics=['acc'])
out = model.fit(x_train, y_train,
batch_size=20,
epochs=200,
verbose=0,
validation_data=[x_val, y_val])
```

To prepare the model for a talos scan, we simply replace the parameters we want to include in the scans with references to our parameter dictionary (example of dictionary provided below). The below example code complete here.

```
def iris_model(x_train, y_train, x_val, y_val, params):
model = Sequential()
model.add(Dense(params['first_neuron'], input_dim=x_train.shape[1], activation=params['activation']))
model.add(Dropout(params['dropout']))
model.add(Dense(y_train.shape[1], activation=params['last_activation']))
model.compile(optimizer=params['optimizer'],
loss=params['losses'],
metrics=['acc'])
out = model.fit(x_train, y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
verbose=0,
validation_data=[x_val, y_val])
return out, model
```

As you can see, the only thing that changed, is the values that we provide for the parameters. We then pass the parameters with a dictionary:

```
p = {'lr': (2, 10, 30),
'first_neuron':[4, 8, 16, 32, 64, 128],
'hidden_layers':[2,3,4,5,6],
'batch_size': [2, 3, 4],
'epochs': [300],
'dropout': (0, 0.40, 10),
'weight_regulizer':[None],
'emb_output_dims': [None],
'optimizer': [Adam, Nadam],
'losses': [categorical_crossentropy, logcosh],
'activation':[relu, elu],
'last_activation': [softmax]}
```

The above example is a simple indication of what is possible. Any parameter that Keras accepts, can be included in the dictionary format.

Talos accepts lists with values, and tuples (start, end, n). Learning rate is normalized to 1 so that for each optimizer, lr=1 is the default Keras setting. Once this is all done, we can run the scan:

```
h = ta.Scan(x, y,
params=p,
dataset_name='first_test',
experiment_no='2',
model=iris_model,
grid_downsample=0.5)
```

## Not All Randomness Are Created Equal

The main optimization strategy focus in Talos is to provide the gold standard random search capabilities. Talos implements three kinds of random generation methods:

- True / Quantum randomness
- Pseudo randomness
- Quasi randomness

The currently implemented methods are:

- Quantum randomness (vacuum based)
- Ambient Sound based randomness
- Sobol sequences
- Halton sequences
- Latin hypercube
- Improved Latin hypercube
- Latin hypercube with a Sudoku-style constraint
- Uniform Mersenne
- Cryptographically sound uniform

Each method differs in discrepancy and other observable aspects.

## More on Optimization Strategies

Talos supports several common optimization strategies:

- Random search
- Grid search
- Manually assisted random or grid search
- Correlation based optimization

The object of abstraction is the keras model configuration, of which n number of permutations is tried in a Talos experiment.

As opposed to adding more complex optimization strategies, which are widely available in various solutions, Talos focus is on:

- adding variations of random variable picking
- reducing the workload of random variable picking

As it stands, both of these approaches are currently under leveraged by other solutions, and under represented in the literature.

## Built With

## License

This project is licensed under the MIT License - see the LICENSE file for details