trainer.py

import collections

import py_paddle.swig_paddle as api
from paddle.proto.ModelConfig_pb2 import ModelConfig
from data_feeder import DataFeeder

from . import event as v2_event
from . import layer as v2_layer
from . import optimizer as v2_optimizer
from . import parameters as v2_parameters

__all__ = ['ITrainer', 'SGD']


def default_event_handler(event):
    """
    Default event handler. It will print some log and save mode.

    TODO(yuyang18): Complete it!
    :param event:
    :return:
    """
    pass


class ITrainer(object):
    """
    The interface of Trainer. The only exposed method is `train`.
    """

    def train(self,
              train_reader_creator,
              topology,
              parameters,
              test_data_reader=None,
              event_handler=None):
        """
        train method.

        :param train_reader_creator:
        :param topology:
        :param parameters:
        :param test_data_reader:
        :param event_handler:
        :return:
        """

        raise NotImplementedError()


class SGD(ITrainer):
    def __init__(self, update_equation):
        """
        Simple SGD Trainer.

        :param update_equation: The optimizer object.
        :type update_equation: v2_optimizer.Optimizer
        """
        if not isinstance(update_equation, v2_optimizer.Optimizer):
            raise ValueError("update equation parameter must be "
                             "paddle.v2.optimizer.Optimizer")
        self.__optimizer__ = update_equation

    def train(self,
              train_reader,
              topology,
              parameters,
              num_passes=1,
              event_handler=None,
              data_types=None,
              reader_dict=None):
        """
        Training method. Will train num_passes of input data.

        :param train_reader:
        :param topology: Network Topology, use one or more Layers to represent it.
        :param parameters: The parameter pools.
        :param num_passes: The total train passes.
        :param event_handler: Event handler. A method will be invoked when event
                              occurred.
        :type event_handler: (BaseEvent) => None
        :param data_types: Not important, will be removed after data refactor.
        :return:
        """
        if event_handler is None:
            event_handler = default_event_handler

        topology = v2_layer.parse_network(topology)

        __check_train_args__(**locals())

        gm = api.GradientMachine.createFromConfigProto(
            topology, api.CREATE_MODE_NORMAL, self.__optimizer__.enable_types())
        assert isinstance(gm, api.GradientMachine)
        parameters.append_gradient_machine(gm)

        updater = self.__optimizer__.create_local_updater()
        updater.init(gm)

        gm.start()
        out_args = api.Arguments.createArguments(0)

        feeder = DataFeeder(data_types, reader_dict)

        for pass_id in xrange(num_passes):
            updater.startPass()
            for batch_id, data_batch in enumerate(train_reader()):
                pass_type = updater.startBatch(len(data_batch))
                gm.forwardBackward(feeder(data_batch), out_args, pass_type)
                for each_param in gm.getParameters():
                    updater.update(each_param)
                # Get cost. We use numpy to calculate total cost for this batch.
                cost_vec = out_args.getSlotValue(0)
                cost_vec = cost_vec.copyToNumpyMat()
                cost = cost_vec.sum() / len(data_batch)
                updater.finishBatch(cost)
                event_handler(
                    v2_event.EndIteration(
                        pass_id=pass_id, batch_id=batch_id, cost=cost))

            updater.finishPass()
        gm.finish()


def __check_train_args__(train_reader, topology, parameters, event_handler,
                         **kwargs):
    """
    Check train function's argument types
    """
    if not callable(train_reader) or not isinstance(train_reader(),
                                                    collections.Iterator):
        raise TypeError('train_data_reader should be a function, '
                        'which can return a iterator')

    if not isinstance(topology, ModelConfig):
        raise TypeError('topology should be a model config')

    if not isinstance(parameters, v2_parameters.Parameters):
        raise TypeError('parameters should be a parameter pool')

    if not callable(event_handler):
        raise TypeError('event handler should be a function')