Skip to content

Latest commit

 

History

History
164 lines (111 loc) · 4.21 KB

README.md

File metadata and controls

164 lines (111 loc) · 4.21 KB
Raw

logoNeuvol

Genetic algorithm to find the best neural network architecture with Keras

Neuvol is a genetic algorithm API for generating neural networks based on Keras. The main idea is to work with data only, without direct architecture constructing.

Grow your own neural network!
  • Data in -> Neural Network Architecture out
  • A large number of allowed layers types

Features:

  • Supported data types: texts, images
  • CNN, Dense, LSTM, Max polling are available
  • Dropout and reshape sub-layers (Flattern) are available too

How-to-use

Short example of usage pipeline.

  • IMDB data:

    from keras.datasets import imdb

import neuvol


def main():
    (x_train, y_train), (x_test, y_test) = imdb.load_data(
        path="imdb.npz",
        num_words=30000,
        skip_top=0,
        maxlen=100,
        seed=113,
        start_char=1,
        oov_char=2,
        index_from=3)

    evaluator = neuvol.Evaluator(x_train, y_train, kfold_number=5)
    mutator = neuvol.Mutator()

    evaluator.create_tokens = False
    evaluator.fitness_measure = 'f1'
    options = {'classes': 2, 'shape': (100,), 'depth': 4}

    wop = neuvol.evolution.Evolution(
                                    stages=10,
                                    population_size=10,
                                    evaluator=evaluator,
                                    mutator=mutator,
                                    data_type='text',
                                    task_type='classification',
                                    active_distribution=True,
                                    freeze=None,
                                    **options)
    wop.cultivate()

    for individ in wop.population_raw_individ:
        print('Architecture: \n')
        print(individ.schema)
        print('\nScore: ', individ.result)


if __name__ == "__main__":
    main()

  • Cifar10 data:

    from keras.datasets import cifar10

import neuvol


def main():
    (x_train, y_train), (x_test, y_test) = cifar10.load_data()

    evaluator = neuvol.Evaluator(x_train, y_train, kfold_number=5)
    mutator = neuvol.Mutator()

    evaluator.create_tokens = False
    evaluator.fitness_measure = 'AUC'
    options = {'classes': 10, 'shape': (32, 32, 3,), 'depth': 4}

    wop = neuvol.evolution.Evolution(
                                    stages=10,
                                    population_size=10,
                                    evaluator=evaluator,
                                    mutator=mutator,
                                    data_type='image',
                                    task_type='classification',
                                    active_distribution=False,
                                    freeze=None,
                                    **options)
    wop.cultivate()

    for individ in wop.population_raw_individ:
        print('Architecture: \n')
        print(individ.schema)
        print('\nScore: ', individ.result)


if __name__ == "__main__":
    main()

    Important note: you should set shape of data in option dictionary.

    Also, you can use GPU for calculation. In order to do that add:

    evaluator.device = 'gpu'

Data format

  • Images:

    X: Array of shape (Number_of_samples, height, width, channels)

    Y: Array classes (Number_of_sample)

    You should specify shape option as (height, width, channels**,**)

  • Texts:

    There are two possibilities:

    1. Process data by yourself - convert text into digits and set:

      evaluator.create_tokens = False

    2. Or use simple keras' tokenizer

      evaluator.create_tokens = True

    X: Array of shape (Number_of_samples, length_of_sentences)

    Y: Array of shape (Number_of_samples)

    You should specify shape option as (length_of_sentences**,**)

TODO

  • Architectures distribution generation
  • Images support
  • Custom text embedding support
  • Regression models
  • Generative networks (??? almost impossible)
  • More available layers
  • More options (assumptions)
  • Logo
  • Visualization