bigdl.keras package

Submodules

bigdl.keras.ToBigDLHelper module

bigdl.keras.ToBigDLHelper.to_bigdl_2d_ordering(order)

bigdl.keras.ToBigDLHelper.to_bigdl_2d_padding(border_mode, *args)

bigdl.keras.ToBigDLHelper.to_bigdl_3d_ordering(order)

bigdl.keras.ToBigDLHelper.to_bigdl_3d_padding(border_mode)

bigdl.keras.ToBigDLHelper.to_bigdl_init(kinit_method)

bigdl.keras.ToBigDLHelper.to_bigdl_reg(reg)

bigdl.keras.backend module

class bigdl.keras.backend.KerasModelWrapper(kmodel)

evaluate(x, y, batch_size=32, sample_weight=None, is_distributed=False)

Evaluate a model by the given metrics. :param x: ndarray or list of ndarray for local mode. RDD[Sample] for distributed mode :param y: ndarray or list of ndarray for local mode and would be None for cluster mode. :param batch_size :param is_distributed: run in local mode or distributed mode. NB: if is_distributed=true, x should be RDD[Sample] and y should be None :return:

fit(x, y=None, batch_size=32, nb_epoch=10, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, is_distributed=False)

Optimize the model by the given options

Parameters:x – ndarray or list of ndarray for local mode.

RDD[Sample] for distributed mode :param y: ndarray or list of ndarray for local mode and would be None for cluster mode. is_distributed: used to control run in local or cluster. the default value is False. NB: if is_distributed=true, x should be RDD[Sample] and y should be None :param is_distributed: Whether to train in local mode or distributed mode :return: A Numpy array or RDD[Sample] of predictions.

predict(x, batch_size=None, verbose=None, is_distributed=False)

Generates output predictions for the input samples, processing the samples in a batched way.

# Arguments x: the input data, as a Numpy array or list of Numpy array for local mode. as RDD[Sample] for distributed mode is_distributed: used to control run in local or cluster. the default value is False # Returns A Numpy array or RDD[Sample] of predictions.

bigdl.keras.backend.with_bigdl_backend(kmodel)

bigdl.keras.converter module

class bigdl.keras.converter.DefinitionLoader(kmodel)

classmethod from_hdf5_path(hdf5_path)

Parameters:hdf5_path – hdf5 path which can be stored in a local file system, HDFS, S3, or any Hadoop-supported file system. Returns:BigDL Model

classmethod from_json_path(json_path)

Parameters:json_path – definition path which can be stored in a local file system, HDFS, S3, or any Hadoop-supported file system. Returns:BigDL Model

classmethod from_json_str(json_str)

classmethod from_kmodel(kmodel)

class bigdl.keras.converter.LayerConverter(klayer, kclayer, input_shape=None)

combo_parameter_layer(blayer, config)

create()

create_activation()

create_activityregularization()

create_atrousconvolution1d()

create_atrousconvolution2d()

create_averagepooling1d()

create_averagepooling2d()

create_averagepooling3d()

create_batchnormalization()

create_bidirectional()

create_convlstm2d()

create_convolution1d()

create_convolution2d()

create_convolution3d()

create_cropping1d()

create_cropping2d()

create_cropping3d()

create_deconvolution2d()

create_dense()

create_dropout()

create_elu()

create_embedding()

create_flatten()

create_gaussiandropout()

create_gaussiannoise()

create_globalaveragepooling1d()

create_globalaveragepooling2d()

create_globalaveragepooling3d()

create_globalmaxpooling1d()

create_globalmaxpooling2d()

create_globalmaxpooling3d()

create_gru()

create_highway()

create_inputlayer()

create_leakyrelu()

create_locallyconnected1d()

create_locallyconnected2d()

create_lstm()

create_masking()

create_maxoutdense()

create_maxpooling1d()

create_maxpooling2d()

create_maxpooling3d()

create_merge()

create_model()

create_parametricsoftplus()

create_permute()

create_prelu()

create_repeatvector()

create_reshape()

create_separableconvolution2d()

create_sequential()

create_simplernn()

create_spatialdropout1d()

create_spatialdropout2d()

create_spatialdropout3d()

create_srelu()

create_thresholdedrelu()

create_timedistributed()

create_timedistributeddense()

create_upsampling1d()

create_upsampling2d()

create_upsampling3d()

create_zeropadding1d()

create_zeropadding2d()

create_zeropadding3d()

fuse(src_blayer, activation)

generate_convlstm2d_cell(klayer, kclayer, input_shape)

generate_gru_cell(klayer, kclayer, input_shape)

generate_lstm_cell(klayer, kclayer, input_shape)

generate_simplernn_cell(klayer, kclayer, input_shape)

get_bdim_order(dim='2D')

get_value_from_init(kinit_method, shape)

class bigdl.keras.converter.WeightLoader

static load_weights_from_hdf5(bmodel, kmodel, filepath, by_name=False)

Loads all layer weights from a HDF5 save file. filepath can be stored in a local file system, HDFS, S3, or any Hadoop-supported file system. If by_name is False (default) weights are loaded based on the network’s execution order topology, meaning layers in the execution seq should be exactly the same the architecture

If by_name is True, weights are loaded into layers only if they share the same name. This is useful for fine-tuning or transfer-learning models where some of the layers have changed.

static load_weights_from_json_hdf5(def_json, weights_hdf5, by_name=False)

The file path can be stored in a local file system, HDFS, S3, or any Hadoop-supported file system.

static load_weights_from_kmodel(bmodel, kmodel)

class bigdl.keras.converter.WeightsConverter

Convert keras weights to bigdl weights The shape of weights would be changed if using different backend, so we only test against TensorFlow backend. TODO: Support th backend as well.

static convert_atrousconvolution1d(klayer, weights)

static convert_atrousconvolution2d(klayer, weights)

static convert_batchnormalization(klayer, weights)

static convert_bidirectional(klayer, weights)

static convert_convlstm2d(klayer, weights)

static convert_convolution1d(klayer, weights)

static convert_convolution2d(klayer, weights)

static convert_convolution3d(klayer, weights)

static convert_deconvolution2d(klayer, weights)

static convert_dense(klayer, weights)

static convert_embedding(klayer, weights)

static convert_gru(klayer, weights)

static convert_highway(klayer, weights)

static convert_locallyconnected1d(klayer, weights)

static convert_locallyconnected2d(klayer, weights)

static convert_lstm(klayer, weights)

static convert_maxoutdense(klayer, weights)

static convert_separableconvolution2d(klayer, weights)

static convert_simplernn(klayer, weights)

static convert_srelu(klayer, weights)

static convert_timedistributed(klayer, weights)

static convert_timedistributeddense(klayer, weights)

static get_bigdl_weights_from_klayer(klayer)

static get_converter(class_name)

static get_weights_from_kmodel(kmodel)

Convert kmodel’s weights to bigdl format. We are supposing the order is the same as the execution order. :param kmodel: keras model :return: list of ndarray

static to_bigdl_weights(klayer, weights)

bigdl.keras.converter.unsupport_exp(name)

bigdl.keras.optimization module

class bigdl.keras.optimization.OptimConverter

static to_bigdl_criterion(kloss)

static to_bigdl_metrics(metrics)

static to_bigdl_optim_method(koptim_method)

Module contents