def __init__(self,
X,
Y,
model,
criterion,
end_trigger,
batch_size,
optim_method=None,
cores=None,
bigdl_type="float"):
if not optim_method:
optim_methods = {model.name(): SGD()}
elif isinstance(optim_method, OptimMethod):
optim_methods = {model.name(): optim_method}
elif isinstance(optim_method, JavaObject):
optim_methods = {
model.name(): OptimMethod(optim_method, bigdl_type)
}
else:
optim_methods = optim_method
if cores is None:
cores = multiprocessing.cpu_count()
JavaValue.__init__(self, None, bigdl_type,
[JTensor.from_ndarray(X) for X in to_list(X)],
JTensor.from_ndarray(Y), model.value, criterion,
optim_methods, end_trigger, batch_size, cores)
def __init__(self,
matrix_b,
matrix_c,
alpha=float(1.0),
beta=float(1.0),
trans_a=0,
trans_b=0,
bigdl_type="float"):
super(Gemm, self).__init__(None, bigdl_type, alpha, beta, trans_a,
trans_b, JTensor.from_ndarray(matrix_b),
JTensor.from_ndarray(matrix_c))
def set_running_std(self, running_std):
"""
Set the running variance of the BatchNormalization layer.
:param running_std: a Numpy array.
"""
callZooFunc(self.bigdl_type, "setRunningStd", self.value,
JTensor.from_ndarray(running_std))
return self
def set_running_mean(self, running_mean):
"""
Set the running mean of the BatchNormalization layer.
:param running_mean: a Numpy array.
"""
callZooFunc(self.bigdl_type, "setRunningMean", self.value,
JTensor.from_ndarray(running_mean))
return self
def __init__(self,
weights=None,
size_average=True,
logProbAsInput=True,
bigdl_type="float"):
super(ClassNLLCriterion, self).__init__(None, bigdl_type,
JTensor.from_ndarray(weights),
size_average, logProbAsInput)
def __init__(self,
learningrate=1e-3,
learningrate_decay=0.0,
weightdecay=0.0,
momentum=0.0,
dampening=DOUBLEMAX,
nesterov=False,
leaningrate_schedule=None,
learningrates=None,
weightdecays=None,
bigdl_type="float"):
super(SGD, self).__init__(
None, bigdl_type, learningrate, learningrate_decay, weightdecay,
momentum, dampening, nesterov, leaningrate_schedule if
(leaningrate_schedule) else Default(),
JTensor.from_ndarray(learningrates),
JTensor.from_ndarray(weightdecays))
def __init__(self,
p=1,
weights=None,
margin=1.0,
size_average=True,
bigdl_type="float"):
super(MultiMarginCriterion,
self).__init__(None, bigdl_type, p,
JTensor.from_ndarray(weights), margin,
size_average)
def __init__(self,
log_prob_as_input=False,
zero_based_label=True,
weights=None,
size_average=True,
padding_value=-1,
bigdl_type="float"):
super(SparseCategoricalCrossEntropy,
self).__init__(None, bigdl_type,
log_prob_as_input, zero_based_label,
JTensor.from_ndarray(weights), size_average,
padding_value)
def set_validation(self,
batch_size,
X_val,
Y_val,
trigger,
val_method=None):
"""
Configure validation settings.
:param batch_size: validation batch size
:param X_val: features of validation dataset
:param Y_val: label of validation dataset
:param trigger: validation interval
:param val_method: the ValidationMethod to use,e.g. "Top1Accuracy", "Top5Accuracy", "Loss"
"""
if val_method is None:
val_method = [Top1Accuracy()]
callBigDlFunc(self.bigdl_type, "setValidation", self.value, batch_size,
trigger,
[JTensor.from_ndarray(X) for X in to_list(X_val)],
JTensor.from_ndarray(Y_val), to_list(val_method))
def save_variable_bigdl(tensors, target_path, bigdl_type="float"):
"""
Save a variable dictionary to a Java object file, so it can be read by BigDL
:param tensors: tensor dictionary
:param target_path: where is the Java object file store
:param bigdl_type: model variable numeric type
:return: nothing
"""
import numpy as np
jtensors = {}
for tn in tensors.keys():
if not isinstance(tensors[tn], np.ndarray):
value = np.array(tensors[tn])
else:
value = tensors[tn]
jtensors[tn] = JTensor.from_ndarray(value)
callBigDlFunc(bigdl_type, "saveTensorDictionary", jtensors, target_path)
def __init__(self,
input_dim,
output_dim,
init="uniform",
weights=None,
trainable=True,
input_length=None,
W_regularizer=None,
input_shape=None,
mask_zero=False,
padding_value=0,
zero_based_id=True,
**kwargs):
if input_length:
input_shape = (input_length, )
super(Embedding,
self).__init__(None, input_dim, output_dim, init,
JTensor.from_ndarray(weights), trainable,
W_regularizer,
list(input_shape) if input_shape else None,
mask_zero, padding_value, zero_based_id, **kwargs)
def from_pytorch(model):
"""
Create a TorchModel directly from PyTorch model, e.g. model in torchvision.models.
:param model: a PyTorch model, or a function to create PyTorch model
"""
weights = []
import types
if isinstance(model, types.FunctionType) or isinstance(model, type):
for param in trainable_param(model()):
weights.append(param.view(-1))
else:
for param in trainable_param(model):
weights.append(param.view(-1))
flatten_weight = torch.nn.utils.parameters_to_vector(
weights).data.numpy()
bys = io.BytesIO()
torch.save(model, bys, pickle_module=zoo_pickle_module)
weights = JTensor.from_ndarray(flatten_weight)
jvalue = callZooFunc("float", "createTorchModel", bys.getvalue(),
weights)
net = TorchModel(jvalue, bys.getvalue())
return net
def __init__(self, weights=None, size_average=True, bigdl_type="float"):
super(MultiLabelSoftMarginCriterion,
self).__init__(None, bigdl_type, JTensor.from_ndarray(weights),
size_average)
def __init__(self, weights=None, size_average=True, bigdl_type="float"):
super(CrossEntropyCriterion,
self).__init__(None, bigdl_type, JTensor.from_ndarray(weights),
size_average)
def __init__(self, data, name=None, bigdl_type="float"):
self.data = data
super(Constant, self).__init__(None, bigdl_type,
JTensor.from_ndarray(data), name)
def __init__(self, value, bigdl_type="float"):
super(Constant, self).__init__(None, bigdl_type,
JTensor.from_ndarray(value))