learning-to-learn

Learning to Learn in TensorFlow

Learning to Learn is an intriguing project that explores the concept of learning optimizers, rather than manually designing them, to improve machine learning algorithms. Built using TensorFlow, a popular machine learning framework, and Sonnet, a library for building complex neural networks, this project aims to implement learning algorithms that adapt and optimize themselves over time.

Dependencies

To get started with the Learning to Learn project, you need to ensure the installation of the following dependencies:

• TensorFlow (version 1.0 or higher): TensorFlow is a powerful open-source platform for machine learning that allows users to build and train various machine learning models.
• Sonnet (version 1.0 or higher): Sonnet is a neural network library that simplifies the process of building modular and reusable neural network components.

Training Process

Training in this project involves a script that facilitates learning over time on defined problems. Here’s how you can initiate this process:

python train.py --problem=mnist --save_path=./mnist

Command-Line Flags for Training:

• save_path: The path where the optimizer is saved after improvements.
• num_epochs: Specifies how many training epochs to execute.
• log_period: Determines the frequency (in epochs) of performance and time reports.
• evaluation_period: Frequency of optimizer evaluations.
• evaluation_epochs: Number of epochs to run during evaluation.
• problem: The problem domain for training (e.g., mnist).
• num_steps: Number of steps used in optimization.
• unroll_length: Refers to the number of steps the optimizer unrolls.
• learning_rate: Sets the learning rate for optimization.
• second_derivatives: If true, the optimizer attempts to compute second derivatives of the loss function.

Evaluation Process

After training, the evaluation script allows for assessing the performance of learned optimizers:

python evaluate.py --problem=mnist --optimizer=L2L --path=./mnist

Command-Line Flags for Evaluation:

• optimizer: Chooses between Adam or a learned optimizer (L2L).
• path: Path to the saved optimizer, useful when L2L optimizer is chosen.
• learning_rate: Required if the Adam optimizer is used.
• num_epochs: The number of epochs for evaluating performance.
• seed: Seed for random number generation to ensure reproducibility.
• problem: Domain for evaluation (aligns with the training problem).
• num_steps: Similar to its training counterpart, it defines optimization steps.

Supported Problems

Currently, the project supports a variety of problem domains suitable for training and evaluation:

• simple: Optimization over a basic one-variable quadratic function.
• simple-multi: A two-variable function optimized by both a learned optimizer and Adam optimizer.
• quadratic: Ten-variable quadratic function in batch processing.
• mnist: Classic image classification task using a two-layer network.
• cifar: Classifies Cifar10 images with a convolutional neural network.
• cifar-multi: Two separate optimizers manage convolutional layer parameters and fully connected layer parameters.

The ease of implementing new problems is enhanced by the MetaOptimizer class, where users can define their own loss functions for minimization (see the problems.py file for examples).

Conclusion

The Learning to Learn project isn't an official Google product but embodies cutting-edge research in machine learning, focusing on creating adaptable learning algorithms. This novel approach pushes the boundaries of traditional optimization strategies, paving the way for more intelligent and efficient machine learning systems.