def __init__(self, upper=None, lower=None, bigdl_type="float"): if upper is not None and lower is not None: upper = upper + 0.0 lower = lower + 0.0 JavaValue.__init__(self, None, bigdl_type, upper, lower) else: JavaValue.__init__(self, None, bigdl_type)
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, min, bigdl_type="float"): """ Create a MinLoss trigger. :param min: min loss """ JavaValue.__init__(self, None, bigdl_type, min)
def __init__(self, interval, bigdl_type="float"): """ Create a SeveralIteration trigger. :param interval: interval is the "n" where an action is triggeredevery "n" iterations """ JavaValue.__init__(self, None, bigdl_type, interval)
def __init__(self, max_epoch, bigdl_type="float"): """ Create a MaxEpoch trigger. :param max_epoch: max_epoch """ JavaValue.__init__(self, None, bigdl_type, max_epoch)
def __init__(self, max, bigdl_type="float"): """ Create a MaxIteration trigger. :param max: max """ JavaValue.__init__(self, None, bigdl_type, max)
def __init__(self, max, bigdl_type="float"): """ Create a MaxScore trigger. :param max: max score """ JavaValue.__init__(self, None, bigdl_type, max)
def __init__(self, log_dir, app_name, bigdl_type="float"): """ Create a TrainSummary. Logs will be saved to log_dir/app_name/train. :param log_dir: the root dir to store the logs :param app_name: the application name """ JavaValue.__init__(self, None, bigdl_type, log_dir, app_name)
def __init__(self, learningrate=1e-3, learningrate_decay=0.0, beta1=0.9, beta2=0.999, epsilon=1e-8, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, learningrate, learningrate_decay, beta1, beta2, epsilon)
def __init__(self, first, *other): """ Create a Or trigger. :param first: first Trigger :param other: other Trigger """ JavaValue.__init__(self, None, "float", first, list(other))
def __init__(self, log_dir, app_name, bigdl_type="float"): """ Create a ValidationSummary. Logs will be saved to log_dir/app_name/train. By default, all ValidationMethod set into optimizer will be recorded and the recording interval is the same as trigger of ValidationMethod in the optimizer. :param log_dir: the root dir to store the logs :param app_name: the application name """ JavaValue.__init__(self, None, bigdl_type, log_dir, app_name)
def __init__(self, monitor, factor=0.1, patience=10, mode="min", epsilon=1e-4, cooldown=0, min_lr=0.0, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, monitor, factor, patience, mode, epsilon, cooldown, min_lr)
def __init__(self, text=None, label=None, jvalue=None, bigdl_type="float"): self.bigdl_type = bigdl_type if jvalue: self.value = jvalue else: assert isinstance(text, six.string_types), "text of a TextFeature should be a string" if label is not None: self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), text, int(label)) else: self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), text)
def __init__(self, classes, iou=0.5, use_voc2007=False, skip_class=-1, bigdl_type="float"): """ :param classes: the number of classes :param iou: the IOU threshold :param use_voc2007: use validation method before voc2010 (i.e. voc2007) :param skip_class: skip calculation on a specific class (e.g. background) """ JavaValue.__init__(self, None, bigdl_type, classes, iou, use_voc2007, skip_class)
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"): JavaValue.__init__(self, 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, max_iter=20, max_eval=DOUBLEMAX, tolfun=1e-5, tolx=1e-9, ncorrection=100, learningrate=1.0, verbose=False, linesearch=None, linesearch_options=None, bigdl_type="float"): if linesearch or linesearch_options: raise ValueError('linesearch and linesearch_options must be None in LBFGS') JavaValue.__init__(self, None, bigdl_type, max_iter, max_eval, tolfun, tolx, ncorrection, learningrate, verbose, linesearch, linesearch_options)
def __init__(self, model, configure=None, bigdl_type="float"): self.bigdl_type = bigdl_type self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), model, configure) self.configure = Configure( jvalue=callBigDlFunc(self.bigdl_type, "getConfigure", self.value))
def __init__(self, X, y, model, criterion, end_trigger, batch_size, optim_method=None, cores=None, bigdl_type="float"): 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_method if optim_method else SGD(), end_trigger, batch_size, cores)
def __init__(self, jvalue, bigdl_type, *args): if (jvalue): assert(type(jvalue) == JavaObject) self.value = jvalue else: self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), *args) self.bigdl_type = bigdl_type
def __init__(self, label_map, thresh=0.3, encoding="png", bigdl_type="float"): self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), label_map, thresh, encoding)
def __init__(self, image=None, label=None, path=None, bigdl_type="float"): image_tensor = JTensor.from_ndarray( image) if image is not None else None label_tensor = JTensor.from_ndarray( label) if label is not None else None self.bigdl_type = bigdl_type self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), image_tensor, label_tensor, path)
def __init__(self, image_rdd=None, label_rdd=None, jvalue=None, bigdl_type="float"): assert jvalue or image_rdd, "jvalue and image_rdd cannot be None in the same time" if jvalue: self.value = jvalue else: # init from image ndarray rdd and label rdd(optional) image_tensor_rdd = image_rdd.map(lambda image: JTensor.from_ndarray(image)) label_tensor_rdd = label_rdd.map(lambda label: JTensor.from_ndarray(label)) if label_rdd else None self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), image_tensor_rdd, label_tensor_rdd) self.bigdl_type = bigdl_type
def __init__(self, model, training_rdd, criterion, end_trigger, batch_size, optim_method=None, bigdl_type="float"): """ Create an optimizer. :param model: the neural net model :param training_data: the training dataset :param criterion: the loss function :param optim_method: the algorithm to use for optimization, e.g. SGD, Adagrad, etc. If optim_method is None, the default algorithm is SGD. :param end_trigger: when to end the optimization :param batch_size: training batch size """ 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 isinstance(training_rdd, RDD): JavaValue.__init__(self, None, bigdl_type, model.value, training_rdd, criterion, optim_methods, end_trigger, batch_size) elif isinstance(training_rdd, DataSet): self.bigdl_type = bigdl_type self.value = callBigDlFunc(self.bigdl_type, "createDistriOptimizerFromDataSet", model.value, training_rdd, criterion, optim_methods, end_trigger, batch_size)
def __init__(self, model, training_rdd, criterion, end_trigger, batch_size, optim_method=None, bigdl_type="float"): """ Create an optimizer. :param model: the neural net model :param traiing_rdd: the training dataset :param criterion: the loss function :param optim_method: the algorithm to use for optimization, e.g. SGD, Adagrad, etc. If optim_method is None, the default algorithm is SGD. :param end_trigger: when to end the optimization :param batch_size: training batch size """ JavaValue.__init__(self, None, bigdl_type, model.value, training_rdd, criterion, optim_method if optim_method else SGD(), end_trigger, batch_size)
def __init__(self, model, training_rdd, criterion, end_trigger, batch_size, optim_method=None, bigdl_type="float"): """ Create an optimizer. :param model: the neural net model :param training_data: the training dataset :param criterion: the loss function :param optim_method: the algorithm to use for optimization, e.g. SGD, Adagrad, etc. If optim_method is None, the default algorithm is SGD. :param end_trigger: when to end the optimization :param batch_size: training batch size """ 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 isinstance(training_rdd, RDD): JavaValue.__init__(self, None, bigdl_type, model.value, training_rdd, criterion, optim_methods, end_trigger, batch_size) elif isinstance(training_rdd, DataSet): self.bigdl_type = bigdl_type self.value = callBigDlFunc(self.bigdl_type, "createDistriOptimizerFromDataSet", model.value, training_rdd, criterion, optim_methods, end_trigger, batch_size)
def __init__(self, pre_processor=None, post_processor=None, batch_per_partition=4, label_map=None, feature_padding_param=None, jvalue=None, bigdl_type="float"): self.bigdl_type=bigdl_type if jvalue: self.value = jvalue else: if pre_processor: assert pre_processor.__class__.__bases__[0].__name__ == "FeatureTransformer",\ "the pre_processor should be subclass of FeatureTransformer" if post_processor: assert post_processor.__class__.__bases__[0].__name__ == "FeatureTransformer", \ "the pre_processor should be subclass of FeatureTransformer" self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), pre_processor, post_processor, batch_per_partition, label_map, feature_padding_param)
def __init__(self, pre_processor=None, post_processor=None, batch_per_partition=4, label_map=None, feature_padding_param=None, jvalue=None, bigdl_type="float"): self.bigdl_type = bigdl_type if jvalue: self.value = jvalue else: if pre_processor: assert issubclass(pre_processor.__class__, Preprocessing), \ "the pre_processor should be subclass of Preprocessing" if post_processor: assert issubclass(post_processor.__class__, Preprocessing), \ "the pre_processor should be subclass of Preprocessing" self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), pre_processor, post_processor, batch_per_partition, label_map, feature_padding_param)
def __init__(self, varianceNormAverage=True, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, varianceNormAverage)
def __init__(self, bigdl_type="float"): """ Create a EveryEpoch trigger. """ JavaValue.__init__(self, None, bigdl_type)
def __init__(self, metric_name, idx): JavaValue.__init__(self, None, "float", metric_name, idx)
def __init__(self, mean, stdv, bigdl_type="float"): mean = mean + 0.0 stdv = stdv + 0.0 JavaValue.__init__(self, None, bigdl_type, mean, stdv)
def __init__(self, value, bigdl_type="float"): value = value + 0.0 JavaValue.__init__(self, None, bigdl_type, value)
def __init__(self, step_sizes, gamma, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, step_sizes, gamma)
def __init__(self, jvalue, bigdl_type, *args): self.value = jvalue if jvalue else callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), *args) self.bigdl_type = bigdl_type
def __init__(self, cri=None, bigdl_type="float"): from bigdl.nn.criterion import ClassNLLCriterion if cri is None: cri = ClassNLLCriterion() JavaValue.__init__(self, None, bigdl_type, cri)
def __init__(self, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type)
def __init__(self, val_method, output_length, target_length): JavaValue.__init__(self, None, "float", val_method, output_length, target_length)
def __init__(self, bigdl_type="float", *args): self.value = callBigDlFunc(bigdl_type, JavaValue.jvm_class_constructor(self), *args)
def __init__(self, iteration_per_epoch, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, iteration_per_epoch)
def __init__(self, metric_name, idx, count_idx): self.name = metric_name self.idx = idx self.count_idx = count_idx JavaValue.__init__(self, None, "float", metric_name, idx, count_idx)
def __init__(self, decay_step, decay_rate, stair_case=False, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, decay_step, decay_rate, stair_case)
def __init__(self, power, max_iteration, bigdl_type="float"): JavaValue.__init__(self, None, bigdl_type, power, max_iteration)
def __init__(self, bigdl_type="float", *args): self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), *args)
def __init__(self, val_method, name, output_indices, label_indices): JavaValue.__init__(self, None, "float", val_method, name, output_indices, label_indices)
def __init__(self, image=None, label=None, path=None, bigdl_type="float"): image_tensor = JTensor.from_ndarray(image) if image is not None else None label_tensor = JTensor.from_ndarray(label) if label is not None else None self.bigdl_type = bigdl_type self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), image_tensor, label_tensor, path)
def __init__(self, label_map, thresh=0.3, encoding="png", bigdl_type="float"): self.value = callBigDlFunc( bigdl_type, JavaValue.jvm_class_constructor(self), label_map, thresh, encoding)