export const nnabla = {}; nnabla.Shape = class Shape { constructor() { this.dim = []; } static decode(reader, length) { const message = new nnabla.Shape(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.dim = reader.array(message.dim, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Shape(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "dim": reader.array(message.dim, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Communicator = class Communicator { static decode(reader, length) { const message = new nnabla.Communicator(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Communicator(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { default: reader.field(tag, message); break; } } return message; } }; nnabla.Context = class Context { constructor() { this.backends = []; } static decode(reader, length) { const message = new nnabla.Context(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.backends.push(reader.string()); break; case 2: message.array_class = reader.string(); break; case 3: message.device_id = reader.string(); break; case 4: message.backend = reader.string(); break; case 5: message.compute_backend = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Context(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "backends": reader.array(message.backends, () => reader.string()); break; case "array_class": message.array_class = reader.string(); break; case "device_id": message.device_id = reader.string(); break; case "backend": message.backend = reader.string(); break; case "compute_backend": message.compute_backend = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Context.prototype.array_class = ""; nnabla.Context.prototype.device_id = ""; nnabla.Context.prototype.backend = ""; nnabla.Context.prototype.compute_backend = ""; nnabla.NNablaProtoBuf = class NNablaProtoBuf { constructor() { this.network = []; this.parameter = []; this.dataset = []; this.optimizer = []; this.monitor = []; this.executor = []; } static decode(reader, length) { const message = new nnabla.NNablaProtoBuf(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.version = reader.string(); break; case 2: message.global_config = nnabla.GlobalConfig.decode(reader, reader.uint32()); break; case 10: message.training_config = nnabla.TrainingConfig.decode(reader, reader.uint32()); break; case 100: message.network.push(nnabla.Network.decode(reader, reader.uint32())); break; case 200: message.parameter.push(nnabla.Parameter.decode(reader, reader.uint32())); break; case 300: message.dataset.push(nnabla.Dataset.decode(reader, reader.uint32())); break; case 400: message.optimizer.push(nnabla.Optimizer.decode(reader, reader.uint32())); break; case 500: message.monitor.push(nnabla.Monitor.decode(reader, reader.uint32())); break; case 600: message.executor.push(nnabla.Executor.decode(reader, reader.uint32())); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NNablaProtoBuf(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "version": message.version = reader.string(); break; case "global_config": message.global_config = nnabla.GlobalConfig.decodeText(reader); break; case "training_config": message.training_config = nnabla.TrainingConfig.decodeText(reader); break; case "network": message.network.push(nnabla.Network.decodeText(reader)); break; case "parameter": message.parameter.push(nnabla.Parameter.decodeText(reader)); break; case "dataset": message.dataset.push(nnabla.Dataset.decodeText(reader)); break; case "optimizer": message.optimizer.push(nnabla.Optimizer.decodeText(reader)); break; case "monitor": message.monitor.push(nnabla.Monitor.decodeText(reader)); break; case "executor": message.executor.push(nnabla.Executor.decodeText(reader)); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NNablaProtoBuf.prototype.version = ""; nnabla.NNablaProtoBuf.prototype.global_config = null; nnabla.NNablaProtoBuf.prototype.training_config = null; nnabla.GlobalConfig = class GlobalConfig { static decode(reader, length) { const message = new nnabla.GlobalConfig(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.default_context = nnabla.Context.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GlobalConfig(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "default_context": message.default_context = nnabla.Context.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GlobalConfig.prototype.default_context = null; nnabla.TrainingConfig = class TrainingConfig { static decode(reader, length) { const message = new nnabla.TrainingConfig(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.max_epoch = reader.int64(); break; case 2: message.iter_per_epoch = reader.int64(); break; case 100: message.save_best = reader.bool(); break; case 200: message.monitor_interval = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TrainingConfig(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "max_epoch": message.max_epoch = reader.int64(); break; case "iter_per_epoch": message.iter_per_epoch = reader.int64(); break; case "save_best": message.save_best = reader.bool(); break; case "monitor_interval": message.monitor_interval = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TrainingConfig.prototype.max_epoch = 0n; nnabla.TrainingConfig.prototype.iter_per_epoch = 0n; nnabla.TrainingConfig.prototype.save_best = false; nnabla.TrainingConfig.prototype.monitor_interval = 0n; nnabla.Network = class Network { constructor() { this.repeat_info = []; this.variable = []; this.function = []; } static decode(reader, length) { const message = new nnabla.Network(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 10: message.batch_size = reader.int64(); break; case 11: message.repeat_info.push(nnabla.RepeatInfo.decode(reader, reader.uint32())); break; case 100: message.variable.push(nnabla.Variable.decode(reader, reader.uint32())); break; case 200: message.function.push(nnabla.Function.decode(reader, reader.uint32())); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Network(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "batch_size": message.batch_size = reader.int64(); break; case "repeat_info": message.repeat_info.push(nnabla.RepeatInfo.decodeText(reader)); break; case "variable": message.variable.push(nnabla.Variable.decodeText(reader)); break; case "function": message.function.push(nnabla.Function.decodeText(reader)); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Network.prototype.name = ""; nnabla.Network.prototype.batch_size = 0n; nnabla.RepeatInfo = class RepeatInfo { static decode(reader, length) { const message = new nnabla.RepeatInfo(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.id = reader.string(); break; case 2: message.times = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RepeatInfo(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "id": message.id = reader.string(); break; case "times": message.times = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RepeatInfo.prototype.id = ""; nnabla.RepeatInfo.prototype.times = 0n; nnabla.RepeatParameter = class RepeatParameter { static decode(reader, length) { const message = new nnabla.RepeatParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.repeat_id = reader.string(); break; case 2: message.times = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RepeatParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "repeat_id": message.repeat_id = reader.string(); break; case "times": message.times = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RepeatParameter.prototype.repeat_id = ""; nnabla.RepeatParameter.prototype.times = 0n; nnabla.RecurrentParameter = class RecurrentParameter { static decode(reader, length) { const message = new nnabla.RecurrentParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.repeat_id = reader.string(); break; case 2: message.length = reader.int64(); break; case 3: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RecurrentParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "repeat_id": message.repeat_id = reader.string(); break; case "length": message.length = reader.int64(); break; case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RecurrentParameter.prototype.repeat_id = ""; nnabla.RecurrentParameter.prototype.length = 0n; nnabla.RecurrentParameter.prototype.axis = 0n; nnabla.Variable = class Variable { constructor() { this.repeat_id = []; } static decode(reader, length) { const message = new nnabla.Variable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 2: message.type = reader.string(); break; case 3: message.repeat_id.push(reader.string()); break; case 20: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 100: message.initializer = nnabla.Initializer.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Variable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "type": message.type = reader.string(); break; case "repeat_id": reader.array(message.repeat_id, () => reader.string()); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "initializer": message.initializer = nnabla.Initializer.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Variable.prototype.name = ""; nnabla.Variable.prototype.type = ""; nnabla.Variable.prototype.shape = null; nnabla.Variable.prototype.initializer = null; nnabla.Initializer = class Initializer { static decode(reader, length) { const message = new nnabla.Initializer(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 2: message.type = reader.string(); break; case 10: message.multiplier = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Initializer(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "type": message.type = reader.string(); break; case "multiplier": message.multiplier = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Initializer.prototype.type = ""; nnabla.Initializer.prototype.multiplier = 0; nnabla.Parameter = class Parameter { constructor() { this.data = []; } static decode(reader, length) { const message = new nnabla.Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 20: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 100: message.data = reader.floats(message.data, tag); break; case 101: message.need_grad = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "data": reader.array(message.data, () => reader.float()); break; case "need_grad": message.need_grad = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Parameter.prototype.variable_name = ""; nnabla.Parameter.prototype.shape = null; nnabla.Parameter.prototype.need_grad = false; nnabla.Dataset = class Dataset { constructor() { this.variable = []; } static decode(reader, length) { const message = new nnabla.Dataset(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 2: message.type = reader.string(); break; case 10: message.uri = reader.string(); break; case 20: message.batch_size = reader.int64(); break; case 30: message.cache_dir = reader.string(); break; case 31: message.overwrite_cache = reader.bool(); break; case 32: message.create_cache_explicitly = reader.bool(); break; case 100: message.shuffle = reader.bool(); break; case 101: message.no_image_normalization = reader.bool(); break; case 200: message.variable.push(reader.string()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Dataset(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "type": message.type = reader.string(); break; case "uri": message.uri = reader.string(); break; case "batch_size": message.batch_size = reader.int64(); break; case "cache_dir": message.cache_dir = reader.string(); break; case "overwrite_cache": message.overwrite_cache = reader.bool(); break; case "create_cache_explicitly": message.create_cache_explicitly = reader.bool(); break; case "shuffle": message.shuffle = reader.bool(); break; case "no_image_normalization": message.no_image_normalization = reader.bool(); break; case "variable": reader.array(message.variable, () => reader.string()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Dataset.prototype.name = ""; nnabla.Dataset.prototype.type = ""; nnabla.Dataset.prototype.uri = ""; nnabla.Dataset.prototype.batch_size = 0n; nnabla.Dataset.prototype.cache_dir = ""; nnabla.Dataset.prototype.overwrite_cache = false; nnabla.Dataset.prototype.create_cache_explicitly = false; nnabla.Dataset.prototype.shuffle = false; nnabla.Dataset.prototype.no_image_normalization = false; nnabla.Optimizer = class Optimizer { constructor() { this.dataset_name = []; this.data_variable = []; this.generator_variable = []; this.loss_variable = []; this.parameter_variable = []; } static decode(reader, length) { const message = new nnabla.Optimizer(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 3: message.order = reader.int64(); break; case 10: message.network_name = reader.string(); break; case 20: message.dataset_name.push(reader.string()); break; case 30: message.solver = nnabla.Solver.decode(reader, reader.uint32()); break; case 40: message.update_interval = reader.int64(); break; case 50: message.data_variable.push(nnabla.DataVariable.decode(reader, reader.uint32())); break; case 60: message.generator_variable.push(nnabla.GeneratorVariable.decode(reader, reader.uint32())); break; case 70: message.loss_variable.push(nnabla.LossVariable.decode(reader, reader.uint32())); break; case 80: message.parameter_variable.push(nnabla.ParameterVariable.decode(reader, reader.uint32())); break; case 100: message.start_iter = reader.int64(); break; case 101: message.end_iter = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Optimizer(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "order": message.order = reader.int64(); break; case "network_name": message.network_name = reader.string(); break; case "dataset_name": reader.array(message.dataset_name, () => reader.string()); break; case "solver": message.solver = nnabla.Solver.decodeText(reader); break; case "update_interval": message.update_interval = reader.int64(); break; case "data_variable": message.data_variable.push(nnabla.DataVariable.decodeText(reader)); break; case "generator_variable": message.generator_variable.push(nnabla.GeneratorVariable.decodeText(reader)); break; case "loss_variable": message.loss_variable.push(nnabla.LossVariable.decodeText(reader)); break; case "parameter_variable": message.parameter_variable.push(nnabla.ParameterVariable.decodeText(reader)); break; case "start_iter": message.start_iter = reader.int64(); break; case "end_iter": message.end_iter = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Optimizer.prototype.name = ""; nnabla.Optimizer.prototype.order = 0n; nnabla.Optimizer.prototype.network_name = ""; nnabla.Optimizer.prototype.solver = null; nnabla.Optimizer.prototype.update_interval = 0n; nnabla.Optimizer.prototype.start_iter = 0n; nnabla.Optimizer.prototype.end_iter = 0n; nnabla.SolverStateParameter = class SolverStateParameter { constructor() { this.data = []; } static decode(reader, length) { const message = new nnabla.SolverStateParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 20: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 100: message.data = reader.floats(message.data, tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SolverStateParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "data": reader.array(message.data, () => reader.float()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SolverStateParameter.prototype.shape = null; nnabla.SolverState = class SolverState { constructor() { this.state_parameter = {}; } static decode(reader, length) { const message = new nnabla.SolverState(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.t = reader.uint32(); break; case 2: reader.entry(message.state_parameter, () => reader.string(), () => nnabla.SolverStateParameter.decode(reader, reader.uint32())); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SolverState(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "t": message.t = reader.uint32(); break; case "state_parameter": reader.entry(message.state_parameter, () => reader.string(), () => nnabla.SolverStateParameter.decodeText(reader)); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SolverState.prototype.t = 0; nnabla.Solver = class Solver { constructor() { this.states = {}; } get parameter() { nnabla.Solver.parameterSet = nnabla.Solver.parameterSet || new Set(["sgd_param", "sgdw_param", "momentum_param", "lars_param", "nesterov_param", "adadelta_param", "adagrad_param", "adabelief_param", "rmsprop_param", "rmsprop_graves_param", "adam_param", "adamw_param", "adabound_param", "adamax_param", "amsgrad_param", "amsbound_param", "lamb_param", "lion_param"]); return Object.keys(this).find((key) => nnabla.Solver.parameterSet.has(key) && this[key] !== null); } static decode(reader, length) { const message = new nnabla.Solver(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 2: message.type = reader.string(); break; case 10: message.context = nnabla.Context.decode(reader, reader.uint32()); break; case 20: message.weight_decay = reader.float(); break; case 40: reader.entry(message.states, () => reader.string(), () => nnabla.SolverState.decode(reader, reader.uint32())); break; case 100: message.sgd_param = nnabla.SgdParameter.decode(reader, reader.uint32()); break; case 101: message.sgdw_param = nnabla.SgdWParameter.decode(reader, reader.uint32()); break; case 102: message.momentum_param = nnabla.MomentumParameter.decode(reader, reader.uint32()); break; case 103: message.lars_param = nnabla.LarsParameter.decode(reader, reader.uint32()); break; case 104: message.nesterov_param = nnabla.NesterovParameter.decode(reader, reader.uint32()); break; case 105: message.adadelta_param = nnabla.AdadeltaParameter.decode(reader, reader.uint32()); break; case 106: message.adagrad_param = nnabla.AdagradParameter.decode(reader, reader.uint32()); break; case 107: message.adabelief_param = nnabla.AdaBeliefParameter.decode(reader, reader.uint32()); break; case 108: message.rmsprop_param = nnabla.RMSpropParameter.decode(reader, reader.uint32()); break; case 109: message.rmsprop_graves_param = nnabla.RMSpropGravesParameter.decode(reader, reader.uint32()); break; case 110: message.adam_param = nnabla.AdamParameter.decode(reader, reader.uint32()); break; case 111: message.adamw_param = nnabla.AdamWParameter.decode(reader, reader.uint32()); break; case 112: message.adabound_param = nnabla.AdaBoundParameter.decode(reader, reader.uint32()); break; case 113: message.adamax_param = nnabla.AdamaxParameter.decode(reader, reader.uint32()); break; case 114: message.amsgrad_param = nnabla.AMSGRADParameter.decode(reader, reader.uint32()); break; case 115: message.amsbound_param = nnabla.AMSBoundParameter.decode(reader, reader.uint32()); break; case 116: message.lamb_param = nnabla.LambParameter.decode(reader, reader.uint32()); break; case 117: message.lion_param = nnabla.LionParameter.decode(reader, reader.uint32()); break; case 200: message.lr_scheduler_type = reader.string(); break; case 210: message.polynomial_scheduler_param = nnabla.PolynomialSchedulerParameter.decode(reader, reader.uint32()); break; case 211: message.cosine_scheduler_param = nnabla.CosineSchedulerParameter.decode(reader, reader.uint32()); break; case 212: message.exponential_scheduler_param = nnabla.ExponentialSchedulerParameter.decode(reader, reader.uint32()); break; case 213: message.step_scheduler_param = nnabla.StepSchedulerParameter.decode(reader, reader.uint32()); break; case 299: message.custom_scheduler_param = nnabla.CustomSchedulerParameter.decode(reader, reader.uint32()); break; case 300: message.lr_warmup_scheduler_type = reader.string(); break; case 310: message.linear_warmup_scheduler_param = nnabla.LinearWarmupSchedulerParameter.decode(reader, reader.uint32()); break; case 30: message.lr_decay = reader.float(); break; case 31: message.lr_decay_interval = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Solver(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "type": message.type = reader.string(); break; case "context": message.context = nnabla.Context.decodeText(reader); break; case "weight_decay": message.weight_decay = reader.float(); break; case "states": reader.entry(message.states, () => reader.string(), () => nnabla.SolverState.decodeText(reader)); break; case "sgd_param": message.sgd_param = nnabla.SgdParameter.decodeText(reader); break; case "sgdw_param": message.sgdw_param = nnabla.SgdWParameter.decodeText(reader); break; case "momentum_param": message.momentum_param = nnabla.MomentumParameter.decodeText(reader); break; case "lars_param": message.lars_param = nnabla.LarsParameter.decodeText(reader); break; case "nesterov_param": message.nesterov_param = nnabla.NesterovParameter.decodeText(reader); break; case "adadelta_param": message.adadelta_param = nnabla.AdadeltaParameter.decodeText(reader); break; case "adagrad_param": message.adagrad_param = nnabla.AdagradParameter.decodeText(reader); break; case "adabelief_param": message.adabelief_param = nnabla.AdaBeliefParameter.decodeText(reader); break; case "rmsprop_param": message.rmsprop_param = nnabla.RMSpropParameter.decodeText(reader); break; case "rmsprop_graves_param": message.rmsprop_graves_param = nnabla.RMSpropGravesParameter.decodeText(reader); break; case "adam_param": message.adam_param = nnabla.AdamParameter.decodeText(reader); break; case "adamw_param": message.adamw_param = nnabla.AdamWParameter.decodeText(reader); break; case "adabound_param": message.adabound_param = nnabla.AdaBoundParameter.decodeText(reader); break; case "adamax_param": message.adamax_param = nnabla.AdamaxParameter.decodeText(reader); break; case "amsgrad_param": message.amsgrad_param = nnabla.AMSGRADParameter.decodeText(reader); break; case "amsbound_param": message.amsbound_param = nnabla.AMSBoundParameter.decodeText(reader); break; case "lamb_param": message.lamb_param = nnabla.LambParameter.decodeText(reader); break; case "lion_param": message.lion_param = nnabla.LionParameter.decodeText(reader); break; case "lr_scheduler_type": message.lr_scheduler_type = reader.string(); break; case "polynomial_scheduler_param": message.polynomial_scheduler_param = nnabla.PolynomialSchedulerParameter.decodeText(reader); break; case "cosine_scheduler_param": message.cosine_scheduler_param = nnabla.CosineSchedulerParameter.decodeText(reader); break; case "exponential_scheduler_param": message.exponential_scheduler_param = nnabla.ExponentialSchedulerParameter.decodeText(reader); break; case "step_scheduler_param": message.step_scheduler_param = nnabla.StepSchedulerParameter.decodeText(reader); break; case "custom_scheduler_param": message.custom_scheduler_param = nnabla.CustomSchedulerParameter.decodeText(reader); break; case "lr_warmup_scheduler_type": message.lr_warmup_scheduler_type = reader.string(); break; case "linear_warmup_scheduler_param": message.linear_warmup_scheduler_param = nnabla.LinearWarmupSchedulerParameter.decodeText(reader); break; case "lr_decay": message.lr_decay = reader.float(); break; case "lr_decay_interval": message.lr_decay_interval = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Solver.prototype.type = ""; nnabla.Solver.prototype.context = null; nnabla.Solver.prototype.weight_decay = 0; nnabla.Solver.prototype.lr_scheduler_type = ""; nnabla.Solver.prototype.polynomial_scheduler_param = null; nnabla.Solver.prototype.cosine_scheduler_param = null; nnabla.Solver.prototype.exponential_scheduler_param = null; nnabla.Solver.prototype.step_scheduler_param = null; nnabla.Solver.prototype.custom_scheduler_param = null; nnabla.Solver.prototype.lr_warmup_scheduler_type = ""; nnabla.Solver.prototype.linear_warmup_scheduler_param = null; nnabla.Solver.prototype.lr_decay = 0; nnabla.Solver.prototype.lr_decay_interval = 0n; nnabla.SgdParameter = class SgdParameter { static decode(reader, length) { const message = new nnabla.SgdParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SgdParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SgdParameter.prototype.lr = 0; nnabla.SgdWParameter = class SgdWParameter { static decode(reader, length) { const message = new nnabla.SgdWParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.momentum = reader.float(); break; case 3: message.wd = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SgdWParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "momentum": message.momentum = reader.float(); break; case "wd": message.wd = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SgdWParameter.prototype.lr = 0; nnabla.SgdWParameter.prototype.momentum = 0; nnabla.SgdWParameter.prototype.wd = 0; nnabla.MomentumParameter = class MomentumParameter { static decode(reader, length) { const message = new nnabla.MomentumParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.momentum = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MomentumParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "momentum": message.momentum = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MomentumParameter.prototype.lr = 0; nnabla.MomentumParameter.prototype.momentum = 0; nnabla.LarsParameter = class LarsParameter { static decode(reader, length) { const message = new nnabla.LarsParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.momentum = reader.float(); break; case 3: message.coefficient = reader.float(); break; case 4: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LarsParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "momentum": message.momentum = reader.float(); break; case "coefficient": message.coefficient = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LarsParameter.prototype.lr = 0; nnabla.LarsParameter.prototype.momentum = 0; nnabla.LarsParameter.prototype.coefficient = 0; nnabla.LarsParameter.prototype.eps = 0; nnabla.NesterovParameter = class NesterovParameter { static decode(reader, length) { const message = new nnabla.NesterovParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.momentum = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NesterovParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "momentum": message.momentum = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NesterovParameter.prototype.lr = 0; nnabla.NesterovParameter.prototype.momentum = 0; nnabla.AdadeltaParameter = class AdadeltaParameter { static decode(reader, length) { const message = new nnabla.AdadeltaParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.decay = reader.float(); break; case 3: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdadeltaParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "decay": message.decay = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdadeltaParameter.prototype.lr = 0; nnabla.AdadeltaParameter.prototype.decay = 0; nnabla.AdadeltaParameter.prototype.eps = 0; nnabla.AdagradParameter = class AdagradParameter { static decode(reader, length) { const message = new nnabla.AdagradParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdagradParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdagradParameter.prototype.lr = 0; nnabla.AdagradParameter.prototype.eps = 0; nnabla.AdaBeliefParameter = class AdaBeliefParameter { static decode(reader, length) { const message = new nnabla.AdaBeliefParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; case 5: message.wd = reader.float(); break; case 6: message.amsgrad = reader.bool(); break; case 7: message.weight_decouple = reader.bool(); break; case 8: message.fixed_decay = reader.bool(); break; case 9: message.rectify = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdaBeliefParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; case "wd": message.wd = reader.float(); break; case "amsgrad": message.amsgrad = reader.bool(); break; case "weight_decouple": message.weight_decouple = reader.bool(); break; case "fixed_decay": message.fixed_decay = reader.bool(); break; case "rectify": message.rectify = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdaBeliefParameter.prototype.alpha = 0; nnabla.AdaBeliefParameter.prototype.beta1 = 0; nnabla.AdaBeliefParameter.prototype.beta2 = 0; nnabla.AdaBeliefParameter.prototype.eps = 0; nnabla.AdaBeliefParameter.prototype.wd = 0; nnabla.AdaBeliefParameter.prototype.amsgrad = false; nnabla.AdaBeliefParameter.prototype.weight_decouple = false; nnabla.AdaBeliefParameter.prototype.fixed_decay = false; nnabla.AdaBeliefParameter.prototype.rectify = false; nnabla.RMSpropParameter = class RMSpropParameter { static decode(reader, length) { const message = new nnabla.RMSpropParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.decay = reader.float(); break; case 3: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RMSpropParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "decay": message.decay = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RMSpropParameter.prototype.lr = 0; nnabla.RMSpropParameter.prototype.decay = 0; nnabla.RMSpropParameter.prototype.eps = 0; nnabla.RMSpropGravesParameter = class RMSpropGravesParameter { static decode(reader, length) { const message = new nnabla.RMSpropGravesParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.decay = reader.float(); break; case 3: message.momentum = reader.float(); break; case 4: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RMSpropGravesParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "decay": message.decay = reader.float(); break; case "momentum": message.momentum = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RMSpropGravesParameter.prototype.lr = 0; nnabla.RMSpropGravesParameter.prototype.decay = 0; nnabla.RMSpropGravesParameter.prototype.momentum = 0; nnabla.RMSpropGravesParameter.prototype.eps = 0; nnabla.AdamParameter = class AdamParameter { static decode(reader, length) { const message = new nnabla.AdamParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdamParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdamParameter.prototype.alpha = 0; nnabla.AdamParameter.prototype.beta1 = 0; nnabla.AdamParameter.prototype.beta2 = 0; nnabla.AdamParameter.prototype.eps = 0; nnabla.AdamWParameter = class AdamWParameter { static decode(reader, length) { const message = new nnabla.AdamWParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; case 5: message.wd = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdamWParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; case "wd": message.wd = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdamWParameter.prototype.alpha = 0; nnabla.AdamWParameter.prototype.beta1 = 0; nnabla.AdamWParameter.prototype.beta2 = 0; nnabla.AdamWParameter.prototype.eps = 0; nnabla.AdamWParameter.prototype.wd = 0; nnabla.AdaBoundParameter = class AdaBoundParameter { static decode(reader, length) { const message = new nnabla.AdaBoundParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; case 5: message.final_lr = reader.float(); break; case 6: message.gamma = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdaBoundParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; case "final_lr": message.final_lr = reader.float(); break; case "gamma": message.gamma = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdaBoundParameter.prototype.alpha = 0; nnabla.AdaBoundParameter.prototype.beta1 = 0; nnabla.AdaBoundParameter.prototype.beta2 = 0; nnabla.AdaBoundParameter.prototype.eps = 0; nnabla.AdaBoundParameter.prototype.final_lr = 0; nnabla.AdaBoundParameter.prototype.gamma = 0; nnabla.AdamaxParameter = class AdamaxParameter { static decode(reader, length) { const message = new nnabla.AdamaxParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AdamaxParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AdamaxParameter.prototype.alpha = 0; nnabla.AdamaxParameter.prototype.beta1 = 0; nnabla.AdamaxParameter.prototype.beta2 = 0; nnabla.AdamaxParameter.prototype.eps = 0; nnabla.AMSGRADParameter = class AMSGRADParameter { static decode(reader, length) { const message = new nnabla.AMSGRADParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; case 5: message.bias_correction = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AMSGRADParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; case "bias_correction": message.bias_correction = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AMSGRADParameter.prototype.alpha = 0; nnabla.AMSGRADParameter.prototype.beta1 = 0; nnabla.AMSGRADParameter.prototype.beta2 = 0; nnabla.AMSGRADParameter.prototype.eps = 0; nnabla.AMSGRADParameter.prototype.bias_correction = false; nnabla.AMSBoundParameter = class AMSBoundParameter { static decode(reader, length) { const message = new nnabla.AMSBoundParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.eps = reader.float(); break; case 5: message.final_lr = reader.float(); break; case 6: message.gamma = reader.float(); break; case 7: message.bias_correction = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AMSBoundParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "eps": message.eps = reader.float(); break; case "final_lr": message.final_lr = reader.float(); break; case "gamma": message.gamma = reader.float(); break; case "bias_correction": message.bias_correction = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AMSBoundParameter.prototype.alpha = 0; nnabla.AMSBoundParameter.prototype.beta1 = 0; nnabla.AMSBoundParameter.prototype.beta2 = 0; nnabla.AMSBoundParameter.prototype.eps = 0; nnabla.AMSBoundParameter.prototype.final_lr = 0; nnabla.AMSBoundParameter.prototype.gamma = 0; nnabla.AMSBoundParameter.prototype.bias_correction = false; nnabla.LambParameter = class LambParameter { static decode(reader, length) { const message = new nnabla.LambParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.eta = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; case 4: message.gamma_l = reader.float(); break; case 5: message.gamma_u = reader.float(); break; case 6: message.eps = reader.float(); break; case 7: message.bias_correction = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LambParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "eta": message.eta = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; case "gamma_l": message.gamma_l = reader.float(); break; case "gamma_u": message.gamma_u = reader.float(); break; case "eps": message.eps = reader.float(); break; case "bias_correction": message.bias_correction = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LambParameter.prototype.eta = 0; nnabla.LambParameter.prototype.beta1 = 0; nnabla.LambParameter.prototype.beta2 = 0; nnabla.LambParameter.prototype.gamma_l = 0; nnabla.LambParameter.prototype.gamma_u = 0; nnabla.LambParameter.prototype.eps = 0; nnabla.LambParameter.prototype.bias_correction = false; nnabla.LionParameter = class LionParameter { static decode(reader, length) { const message = new nnabla.LionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.lr = reader.float(); break; case 2: message.beta1 = reader.float(); break; case 3: message.beta2 = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "lr": message.lr = reader.float(); break; case "beta1": message.beta1 = reader.float(); break; case "beta2": message.beta2 = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LionParameter.prototype.lr = 0; nnabla.LionParameter.prototype.beta1 = 0; nnabla.LionParameter.prototype.beta2 = 0; nnabla.PolynomialSchedulerParameter = class PolynomialSchedulerParameter { static decode(reader, length) { const message = new nnabla.PolynomialSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.max_iter = reader.float(); break; case 2: message.power = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PolynomialSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "max_iter": message.max_iter = reader.float(); break; case "power": message.power = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PolynomialSchedulerParameter.prototype.max_iter = 0; nnabla.PolynomialSchedulerParameter.prototype.power = 0; nnabla.CosineSchedulerParameter = class CosineSchedulerParameter { static decode(reader, length) { const message = new nnabla.CosineSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.max_iter = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CosineSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "max_iter": message.max_iter = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CosineSchedulerParameter.prototype.max_iter = 0; nnabla.ExponentialSchedulerParameter = class ExponentialSchedulerParameter { static decode(reader, length) { const message = new nnabla.ExponentialSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.gamma = reader.float(); break; case 2: message.iter_interval = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ExponentialSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "gamma": message.gamma = reader.float(); break; case "iter_interval": message.iter_interval = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ExponentialSchedulerParameter.prototype.gamma = 0; nnabla.ExponentialSchedulerParameter.prototype.iter_interval = 0n; nnabla.StepSchedulerParameter = class StepSchedulerParameter { constructor() { this.iter_steps = []; } static decode(reader, length) { const message = new nnabla.StepSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.gamma = reader.float(); break; case 2: message.iter_steps = reader.array(message.iter_steps, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.StepSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "gamma": message.gamma = reader.float(); break; case "iter_steps": reader.array(message.iter_steps, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.StepSchedulerParameter.prototype.gamma = 0; nnabla.CustomSchedulerParameter = class CustomSchedulerParameter { constructor() { this.data_variable = []; this.output_variable = []; } static decode(reader, length) { const message = new nnabla.CustomSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.max_iter = reader.float(); break; case 10: message.network_name = reader.string(); break; case 50: message.data_variable.push(nnabla.DataVariable.decode(reader, reader.uint32())); break; case 80: message.output_variable.push(nnabla.OutputVariable.decode(reader, reader.uint32())); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CustomSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "max_iter": message.max_iter = reader.float(); break; case "network_name": message.network_name = reader.string(); break; case "data_variable": message.data_variable.push(nnabla.DataVariable.decodeText(reader)); break; case "output_variable": message.output_variable.push(nnabla.OutputVariable.decodeText(reader)); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CustomSchedulerParameter.prototype.max_iter = 0; nnabla.CustomSchedulerParameter.prototype.network_name = ""; nnabla.LinearWarmupSchedulerParameter = class LinearWarmupSchedulerParameter { static decode(reader, length) { const message = new nnabla.LinearWarmupSchedulerParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.warmup_iter = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LinearWarmupSchedulerParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "warmup_iter": message.warmup_iter = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LinearWarmupSchedulerParameter.prototype.warmup_iter = 0n; nnabla.DataVariable = class DataVariable { static decode(reader, length) { const message = new nnabla.DataVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 3: message.data_name = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DataVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "data_name": message.data_name = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DataVariable.prototype.variable_name = ""; nnabla.DataVariable.prototype.data_name = ""; nnabla.GeneratorVariable = class GeneratorVariable { static decode(reader, length) { const message = new nnabla.GeneratorVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 2: message.type = reader.string(); break; case 3: message.multiplier = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GeneratorVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "type": message.type = reader.string(); break; case "multiplier": message.multiplier = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GeneratorVariable.prototype.variable_name = ""; nnabla.GeneratorVariable.prototype.type = ""; nnabla.GeneratorVariable.prototype.multiplier = 0; nnabla.LossVariable = class LossVariable { static decode(reader, length) { const message = new nnabla.LossVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LossVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LossVariable.prototype.variable_name = ""; nnabla.ParameterVariable = class ParameterVariable { static decode(reader, length) { const message = new nnabla.ParameterVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 2: message.learning_rate_multiplier = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ParameterVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "learning_rate_multiplier": message.learning_rate_multiplier = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ParameterVariable.prototype.variable_name = ""; nnabla.ParameterVariable.prototype.learning_rate_multiplier = 0; nnabla.Monitor = class Monitor { constructor() { this.dataset_name = []; this.data_variable = []; this.generator_variable = []; this.monitor_variable = []; } static decode(reader, length) { const message = new nnabla.Monitor(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 10: message.network_name = reader.string(); break; case 20: message.dataset_name.push(reader.string()); break; case 50: message.data_variable.push(nnabla.DataVariable.decode(reader, reader.uint32())); break; case 60: message.generator_variable.push(nnabla.GeneratorVariable.decode(reader, reader.uint32())); break; case 70: message.monitor_variable.push(nnabla.MonitorVariable.decode(reader, reader.uint32())); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Monitor(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "network_name": message.network_name = reader.string(); break; case "dataset_name": reader.array(message.dataset_name, () => reader.string()); break; case "data_variable": message.data_variable.push(nnabla.DataVariable.decodeText(reader)); break; case "generator_variable": message.generator_variable.push(nnabla.GeneratorVariable.decodeText(reader)); break; case "monitor_variable": message.monitor_variable.push(nnabla.MonitorVariable.decodeText(reader)); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Monitor.prototype.name = ""; nnabla.Monitor.prototype.network_name = ""; nnabla.MonitorVariable = class MonitorVariable { static decode(reader, length) { const message = new nnabla.MonitorVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 2: message.type = reader.string(); break; case 3: message.data_name = reader.string(); break; case 100: message.multiplier = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MonitorVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "type": message.type = reader.string(); break; case "data_name": message.data_name = reader.string(); break; case "multiplier": message.multiplier = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MonitorVariable.prototype.variable_name = ""; nnabla.MonitorVariable.prototype.type = ""; nnabla.MonitorVariable.prototype.data_name = ""; nnabla.MonitorVariable.prototype.multiplier = 0; nnabla.Executor = class Executor { constructor() { this.data_variable = []; this.generator_variable = []; this.loss_variable = []; this.output_variable = []; this.parameter_variable = []; } static decode(reader, length) { const message = new nnabla.Executor(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 10: message.network_name = reader.string(); break; case 20: message.num_evaluations = reader.int64(); break; case 21: message.repeat_evaluation_type = reader.string(); break; case 30: message.need_back_propagation = reader.bool(); break; case 50: message.data_variable.push(nnabla.DataVariable.decode(reader, reader.uint32())); break; case 60: message.generator_variable.push(nnabla.GeneratorVariable.decode(reader, reader.uint32())); break; case 70: message.loss_variable.push(nnabla.LossVariable.decode(reader, reader.uint32())); break; case 80: message.output_variable.push(nnabla.OutputVariable.decode(reader, reader.uint32())); break; case 90: message.parameter_variable.push(nnabla.ParameterVariable.decode(reader, reader.uint32())); break; case 101: message.no_image_normalization = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Executor(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "network_name": message.network_name = reader.string(); break; case "num_evaluations": message.num_evaluations = reader.int64(); break; case "repeat_evaluation_type": message.repeat_evaluation_type = reader.string(); break; case "need_back_propagation": message.need_back_propagation = reader.bool(); break; case "data_variable": message.data_variable.push(nnabla.DataVariable.decodeText(reader)); break; case "generator_variable": message.generator_variable.push(nnabla.GeneratorVariable.decodeText(reader)); break; case "loss_variable": message.loss_variable.push(nnabla.LossVariable.decodeText(reader)); break; case "output_variable": message.output_variable.push(nnabla.OutputVariable.decodeText(reader)); break; case "parameter_variable": message.parameter_variable.push(nnabla.ParameterVariable.decodeText(reader)); break; case "no_image_normalization": message.no_image_normalization = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Executor.prototype.name = ""; nnabla.Executor.prototype.network_name = ""; nnabla.Executor.prototype.num_evaluations = 0n; nnabla.Executor.prototype.repeat_evaluation_type = ""; nnabla.Executor.prototype.need_back_propagation = false; nnabla.Executor.prototype.no_image_normalization = false; nnabla.OutputVariable = class OutputVariable { static decode(reader, length) { const message = new nnabla.OutputVariable(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.variable_name = reader.string(); break; case 2: message.type = reader.string(); break; case 3: message.data_name = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.OutputVariable(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "variable_name": message.variable_name = reader.string(); break; case "type": message.type = reader.string(); break; case "data_name": message.data_name = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.OutputVariable.prototype.variable_name = ""; nnabla.OutputVariable.prototype.type = ""; nnabla.OutputVariable.prototype.data_name = ""; nnabla.Function = class Function { constructor() { this.repeat_id = []; this.input = []; this.output = []; } get parameter() { nnabla.Function.parameterSet = nnabla.Function.parameterSet || new Set(["affine_param", "rnn_param", "lstm_param", "gru_param", "convolution_param", "fused_convolution_param", "depthwise_convolution_param", "deconvolution_param", "depthwise_deconvolution_param", "deformable_convolution_param", "max_pooling_param", "average_pooling_param", "sum_pooling_param", "unpooling_param", "roi_align_param", "relu_param", "leaky_relu_param", "softmax_param", "log_softmax_param", "elu_param", "selu_param", "crelu_param", "celu_param", "prelu_param", "softplus_param", "fused_batch_normalization_param", "batch_normalization_param", "group_normalization_param", "instance_normalization_param", "layer_normalization_param", "norm_normalization_param", "sync_batch_normalization_param", "tensor_normalization_param", "weight_normalization_param", "weight_standardization_param", "spectral_norm_param", "mean_subtraction_param", "clip_grad_by_norm_param", "sum_param", "cumsum_param", "mean_param", "max_param", "min_param", "norm_param", "prod_param", "cumprod_param", "add2_param", "bc_add2_param", "sub2_param", "mul2_param", "div2_param", "pow2_param", "add_scalar_param", "mul_scalar_param", "pow_scalar_param", "r_sub_scalar_param", "r_div_scalar_param", "r_pow_scalar_param", "sign_param", "minimum_scalar_param", "maximum_scalar_param", "searchsorted_param", "logical_and_scalar_param", "logical_or_scalar_param", "logical_xor_scalar_param", "equal_scalar_param", "not_equal_scalar_param", "greater_equal_scalar_param", "greater_scalar_param", "less_equal_scalar_param", "less_scalar_param", "reset_nan_param", "reset_inf_param", "constant_param", "arange_param", "linspace_param", "batch_matmul_param", "round_param", "ceil_param", "floor_param", "concatenate_param", "split_param", "stack_param", "slice_param", "pad_param", "transpose_param", "broadcast_param", "broadcast_to_param", "tile_param", "one_hot_param", "flip_param", "shift_param", "sort_param", "reshape_param", "shape_param", "trilu_param", "meshgrid_param", "batch_cholesky_param", "gather_param", "scatter_nd_param", "scatter_add_param", "bool_fill_param", "pack_padded_sequence_param", "pad_packed_sequence_param", "interpolate_param", "onnx_resize_param", "fft_param", "ifft_param", "stft_param", "istft_param", "dropout_param", "top_k_data_param", "top_k_grad_param", "rand_param", "randint_param", "randn_param", "rand_binomial_param", "rand_beta_param", "rand_gamma_param", "random_choice_param", "random_crop_param", "random_flip_param", "random_shift_param", "random_erase_param", "image_augmentation_param", "softmax_cross_entropy_param", "categorical_cross_entropy_param", "huber_loss_param", "epsilon_insensitive_loss_param", "kl_multinomial_param", "affine_grid_param", "warp_by_grid_param", "binary_connect_affine_param", "binary_connect_convolution_param", "binary_weight_affine_param", "binary_weight_convolution_param", "inq_affine_param", "inq_convolution_param", "fixed_point_quantize_param", "min_max_quantize_param", "pow2_quantize_param", "prune_param", "quantize_linear_param", "top_n_error_param", "confusion_matrix_param", "vat_noise_param", "sink_param", "nms_detection2d_param", "onnx_non_max_suppression_param", "max_pooling_backward_param", "patch_correlation_param", "unique_param", "eye_like_param", "mod2_param", "bit_shift_param", "einsum_param"]); return Object.keys(this).find((key) => nnabla.Function.parameterSet.has(key) && this[key] !== null); } static decode(reader, length) { const message = new nnabla.Function(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.name = reader.string(); break; case 2: message.type = reader.string(); break; case 3: message.repeat_id.push(reader.string()); break; case 10: message.context = nnabla.Context.decode(reader, reader.uint32()); break; case 20: message.input.push(reader.string()); break; case 30: message.output.push(reader.string()); break; case 1001: message.affine_param = nnabla.AffineParameter.decode(reader, reader.uint32()); break; case 1002: message.rnn_param = nnabla.RNNParameter.decode(reader, reader.uint32()); break; case 1003: message.lstm_param = nnabla.LSTMParameter.decode(reader, reader.uint32()); break; case 1004: message.gru_param = nnabla.GRUParameter.decode(reader, reader.uint32()); break; case 1005: message.convolution_param = nnabla.ConvolutionParameter.decode(reader, reader.uint32()); break; case 1006: message.fused_convolution_param = nnabla.FusedConvolutionParameter.decode(reader, reader.uint32()); break; case 1007: message.depthwise_convolution_param = nnabla.DepthwiseConvolutionParameter.decode(reader, reader.uint32()); break; case 1008: message.deconvolution_param = nnabla.DeconvolutionParameter.decode(reader, reader.uint32()); break; case 1009: message.depthwise_deconvolution_param = nnabla.DepthwiseDeconvolutionParameter.decode(reader, reader.uint32()); break; case 1010: message.deformable_convolution_param = nnabla.DeformableConvolutionParameter.decode(reader, reader.uint32()); break; case 1012: message.max_pooling_param = nnabla.MaxPoolingParameter.decode(reader, reader.uint32()); break; case 1013: message.average_pooling_param = nnabla.AveragePoolingParameter.decode(reader, reader.uint32()); break; case 1015: message.sum_pooling_param = nnabla.SumPoolingParameter.decode(reader, reader.uint32()); break; case 1016: message.unpooling_param = nnabla.UnpoolingParameter.decode(reader, reader.uint32()); break; case 1018: message.roi_align_param = nnabla.RoiAlignParameter.decode(reader, reader.uint32()); break; case 1022: message.relu_param = nnabla.ReLUParameter.decode(reader, reader.uint32()); break; case 1023: message.leaky_relu_param = nnabla.LeakyReLUParameter.decode(reader, reader.uint32()); break; case 1024: message.softmax_param = nnabla.SoftmaxParameter.decode(reader, reader.uint32()); break; case 1025: message.log_softmax_param = nnabla.LogSoftmaxParameter.decode(reader, reader.uint32()); break; case 1026: message.elu_param = nnabla.ELUParameter.decode(reader, reader.uint32()); break; case 1027: message.selu_param = nnabla.SELUParameter.decode(reader, reader.uint32()); break; case 1028: message.crelu_param = nnabla.CReLUParameter.decode(reader, reader.uint32()); break; case 1029: message.celu_param = nnabla.CELUParameter.decode(reader, reader.uint32()); break; case 1030: message.prelu_param = nnabla.PReLUParameter.decode(reader, reader.uint32()); break; case 1037: message.softplus_param = nnabla.SoftPlusParameter.decode(reader, reader.uint32()); break; case 1041: message.fused_batch_normalization_param = nnabla.FusedBatchNormalizationParameter.decode(reader, reader.uint32()); break; case 1042: message.batch_normalization_param = nnabla.BatchNormalizationParameter.decode(reader, reader.uint32()); break; case 1043: message.group_normalization_param = nnabla.GroupNormalizationParameter.decode(reader, reader.uint32()); break; case 1044: message.instance_normalization_param = nnabla.InstanceNormalizationParameter.decode(reader, reader.uint32()); break; case 1045: message.layer_normalization_param = nnabla.LayerNormalizationParameter.decode(reader, reader.uint32()); break; case 1046: message.norm_normalization_param = nnabla.NormNormalizationParameter.decode(reader, reader.uint32()); break; case 1047: message.sync_batch_normalization_param = nnabla.SyncBatchNormalizationParameter.decode(reader, reader.uint32()); break; case 1048: message.tensor_normalization_param = nnabla.TensorNormalizationParameter.decode(reader, reader.uint32()); break; case 1049: message.weight_normalization_param = nnabla.WeightNormalizationParameter.decode(reader, reader.uint32()); break; case 1050: message.weight_standardization_param = nnabla.WeightStandardizationParameter.decode(reader, reader.uint32()); break; case 1051: message.spectral_norm_param = nnabla.SpectralNormParameter.decode(reader, reader.uint32()); break; case 1052: message.mean_subtraction_param = nnabla.MeanSubtractionParameter.decode(reader, reader.uint32()); break; case 1054: message.clip_grad_by_norm_param = nnabla.ClipGradByNormParameter.decode(reader, reader.uint32()); break; case 1055: message.sum_param = nnabla.SumParameter.decode(reader, reader.uint32()); break; case 1056: message.cumsum_param = nnabla.CumSumParameter.decode(reader, reader.uint32()); break; case 1057: message.mean_param = nnabla.MeanParameter.decode(reader, reader.uint32()); break; case 1058: message.max_param = nnabla.MaxParameter.decode(reader, reader.uint32()); break; case 1059: message.min_param = nnabla.MinParameter.decode(reader, reader.uint32()); break; case 1060: message.norm_param = nnabla.NormParameter.decode(reader, reader.uint32()); break; case 1061: message.prod_param = nnabla.ProdParameter.decode(reader, reader.uint32()); break; case 1062: message.cumprod_param = nnabla.CumProdParameter.decode(reader, reader.uint32()); break; case 1065: message.add2_param = nnabla.Add2Parameter.decode(reader, reader.uint32()); break; case 1067: message.bc_add2_param = nnabla.BcAdd2Parameter.decode(reader, reader.uint32()); break; case 1068: message.sub2_param = nnabla.Sub2Parameter.decode(reader, reader.uint32()); break; case 1069: message.mul2_param = nnabla.Mul2Parameter.decode(reader, reader.uint32()); break; case 1071: message.div2_param = nnabla.Div2Parameter.decode(reader, reader.uint32()); break; case 1072: message.pow2_param = nnabla.Pow2Parameter.decode(reader, reader.uint32()); break; case 1073: message.add_scalar_param = nnabla.AddScalarParameter.decode(reader, reader.uint32()); break; case 1074: message.mul_scalar_param = nnabla.MulScalarParameter.decode(reader, reader.uint32()); break; case 1075: message.pow_scalar_param = nnabla.PowScalarParameter.decode(reader, reader.uint32()); break; case 1076: message.r_sub_scalar_param = nnabla.RSubScalarParameter.decode(reader, reader.uint32()); break; case 1077: message.r_div_scalar_param = nnabla.RDivScalarParameter.decode(reader, reader.uint32()); break; case 1078: message.r_pow_scalar_param = nnabla.RPowScalarParameter.decode(reader, reader.uint32()); break; case 1079: message.sign_param = nnabla.SignParameter.decode(reader, reader.uint32()); break; case 1082: message.minimum_scalar_param = nnabla.MinimumScalarParameter.decode(reader, reader.uint32()); break; case 1083: message.maximum_scalar_param = nnabla.MaximumScalarParameter.decode(reader, reader.uint32()); break; case 1093: message.searchsorted_param = nnabla.SearchSortedParameter.decode(reader, reader.uint32()); break; case 1094: message.logical_and_scalar_param = nnabla.LogicalAndScalarParameter.decode(reader, reader.uint32()); break; case 1095: message.logical_or_scalar_param = nnabla.LogicalOrScalarParameter.decode(reader, reader.uint32()); break; case 1096: message.logical_xor_scalar_param = nnabla.LogicalXorScalarParameter.decode(reader, reader.uint32()); break; case 1097: message.equal_scalar_param = nnabla.EqualScalarParameter.decode(reader, reader.uint32()); break; case 1098: message.not_equal_scalar_param = nnabla.NotEqualScalarParameter.decode(reader, reader.uint32()); break; case 1099: message.greater_equal_scalar_param = nnabla.GreaterEqualScalarParameter.decode(reader, reader.uint32()); break; case 1100: message.greater_scalar_param = nnabla.GreaterScalarParameter.decode(reader, reader.uint32()); break; case 1101: message.less_equal_scalar_param = nnabla.LessEqualScalarParameter.decode(reader, reader.uint32()); break; case 1102: message.less_scalar_param = nnabla.LessScalarParameter.decode(reader, reader.uint32()); break; case 1106: message.reset_nan_param = nnabla.ResetNaNParameter.decode(reader, reader.uint32()); break; case 1107: message.reset_inf_param = nnabla.ResetInfParameter.decode(reader, reader.uint32()); break; case 1109: message.constant_param = nnabla.ConstantParameter.decode(reader, reader.uint32()); break; case 1110: message.arange_param = nnabla.ArangeParameter.decode(reader, reader.uint32()); break; case 1111: message.linspace_param = nnabla.LinspaceParameter.decode(reader, reader.uint32()); break; case 1116: message.batch_matmul_param = nnabla.BatchMatmulParameter.decode(reader, reader.uint32()); break; case 1117: message.round_param = nnabla.RoundParameter.decode(reader, reader.uint32()); break; case 1118: message.ceil_param = nnabla.CeilParameter.decode(reader, reader.uint32()); break; case 1119: message.floor_param = nnabla.FloorParameter.decode(reader, reader.uint32()); break; case 1133: message.concatenate_param = nnabla.ConcatenateParameter.decode(reader, reader.uint32()); break; case 1134: message.split_param = nnabla.SplitParameter.decode(reader, reader.uint32()); break; case 1135: message.stack_param = nnabla.StackParameter.decode(reader, reader.uint32()); break; case 1136: message.slice_param = nnabla.SliceParameter.decode(reader, reader.uint32()); break; case 1137: message.pad_param = nnabla.PadParameter.decode(reader, reader.uint32()); break; case 1138: message.transpose_param = nnabla.TransposeParameter.decode(reader, reader.uint32()); break; case 1139: message.broadcast_param = nnabla.BroadcastParameter.decode(reader, reader.uint32()); break; case 1140: message.broadcast_to_param = nnabla.BroadcastToParameter.decode(reader, reader.uint32()); break; case 1141: message.tile_param = nnabla.TileParameter.decode(reader, reader.uint32()); break; case 1142: message.one_hot_param = nnabla.OneHotParameter.decode(reader, reader.uint32()); break; case 1143: message.flip_param = nnabla.FlipParameter.decode(reader, reader.uint32()); break; case 1144: message.shift_param = nnabla.ShiftParameter.decode(reader, reader.uint32()); break; case 1145: message.sort_param = nnabla.SortParameter.decode(reader, reader.uint32()); break; case 1146: message.reshape_param = nnabla.ReshapeParameter.decode(reader, reader.uint32()); break; case 1147: message.shape_param = nnabla.ShapeParameter.decode(reader, reader.uint32()); break; case 1150: message.trilu_param = nnabla.TriluParameter.decode(reader, reader.uint32()); break; case 1151: message.meshgrid_param = nnabla.MeshgridParameter.decode(reader, reader.uint32()); break; case 1155: message.batch_cholesky_param = nnabla.BatchCholeskyParameter.decode(reader, reader.uint32()); break; case 1157: message.gather_param = nnabla.GatherParameter.decode(reader, reader.uint32()); break; case 1160: message.scatter_nd_param = nnabla.ScatterNdParameter.decode(reader, reader.uint32()); break; case 1161: message.scatter_add_param = nnabla.ScatterAddParameter.decode(reader, reader.uint32()); break; case 1163: message.bool_fill_param = nnabla.BoolFillParameter.decode(reader, reader.uint32()); break; case 1164: message.pack_padded_sequence_param = nnabla.PackPaddedSequenceParameter.decode(reader, reader.uint32()); break; case 1165: message.pad_packed_sequence_param = nnabla.PadPackedSequenceParameter.decode(reader, reader.uint32()); break; case 1167: message.interpolate_param = nnabla.InterpolateParameter.decode(reader, reader.uint32()); break; case 1168: message.onnx_resize_param = nnabla.ONNXResizeParameter.decode(reader, reader.uint32()); break; case 1169: message.fft_param = nnabla.FFTParameter.decode(reader, reader.uint32()); break; case 1170: message.ifft_param = nnabla.IFFTParameter.decode(reader, reader.uint32()); break; case 1171: message.stft_param = nnabla.STFTParameter.decode(reader, reader.uint32()); break; case 1172: message.istft_param = nnabla.ISTFTParameter.decode(reader, reader.uint32()); break; case 1173: message.dropout_param = nnabla.DropoutParameter.decode(reader, reader.uint32()); break; case 1174: message.top_k_data_param = nnabla.TopKDataParameter.decode(reader, reader.uint32()); break; case 1175: message.top_k_grad_param = nnabla.TopKGradParameter.decode(reader, reader.uint32()); break; case 1176: message.rand_param = nnabla.RandParameter.decode(reader, reader.uint32()); break; case 1177: message.randint_param = nnabla.RandintParameter.decode(reader, reader.uint32()); break; case 1178: message.randn_param = nnabla.RandnParameter.decode(reader, reader.uint32()); break; case 1179: message.rand_binomial_param = nnabla.RandBinomialParameter.decode(reader, reader.uint32()); break; case 1180: message.rand_beta_param = nnabla.RandBetaParameter.decode(reader, reader.uint32()); break; case 1181: message.rand_gamma_param = nnabla.RandGammaParameter.decode(reader, reader.uint32()); break; case 1182: message.random_choice_param = nnabla.RandomChoiceParameter.decode(reader, reader.uint32()); break; case 1183: message.random_crop_param = nnabla.RandomCropParameter.decode(reader, reader.uint32()); break; case 1184: message.random_flip_param = nnabla.RandomFlipParameter.decode(reader, reader.uint32()); break; case 1185: message.random_shift_param = nnabla.RandomShiftParameter.decode(reader, reader.uint32()); break; case 1186: message.random_erase_param = nnabla.RandomEraseParameter.decode(reader, reader.uint32()); break; case 1187: message.image_augmentation_param = nnabla.ImageAugmentationParameter.decode(reader, reader.uint32()); break; case 1190: message.softmax_cross_entropy_param = nnabla.SoftmaxCrossEntropyParameter.decode(reader, reader.uint32()); break; case 1191: message.categorical_cross_entropy_param = nnabla.CategoricalCrossEntropyParameter.decode(reader, reader.uint32()); break; case 1194: message.huber_loss_param = nnabla.HuberLossParameter.decode(reader, reader.uint32()); break; case 1195: message.epsilon_insensitive_loss_param = nnabla.EpsilonInsensitiveLossParameter.decode(reader, reader.uint32()); break; case 1196: message.kl_multinomial_param = nnabla.KLMultinomialParameter.decode(reader, reader.uint32()); break; case 1197: message.affine_grid_param = nnabla.AffineGridParameter.decode(reader, reader.uint32()); break; case 1198: message.warp_by_grid_param = nnabla.WarpByGridParameter.decode(reader, reader.uint32()); break; case 1202: message.binary_connect_affine_param = nnabla.BinaryConnectAffineParameter.decode(reader, reader.uint32()); break; case 1203: message.binary_connect_convolution_param = nnabla.BinaryConnectConvolutionParameter.decode(reader, reader.uint32()); break; case 1204: message.binary_weight_affine_param = nnabla.BinaryWeightAffineParameter.decode(reader, reader.uint32()); break; case 1205: message.binary_weight_convolution_param = nnabla.BinaryWeightConvolutionParameter.decode(reader, reader.uint32()); break; case 1206: message.inq_affine_param = nnabla.INQAffineParameter.decode(reader, reader.uint32()); break; case 1207: message.inq_convolution_param = nnabla.INQConvolutionParameter.decode(reader, reader.uint32()); break; case 1208: message.fixed_point_quantize_param = nnabla.FixedPointQuantizeParameter.decode(reader, reader.uint32()); break; case 1209: message.min_max_quantize_param = nnabla.MinMaxQuantizeParameter.decode(reader, reader.uint32()); break; case 1210: message.pow2_quantize_param = nnabla.Pow2QuantizeParameter.decode(reader, reader.uint32()); break; case 1211: message.prune_param = nnabla.PruneParameter.decode(reader, reader.uint32()); break; case 1212: message.quantize_linear_param = nnabla.QuantizeLinearParameter.decode(reader, reader.uint32()); break; case 1214: message.top_n_error_param = nnabla.TopNErrorParameter.decode(reader, reader.uint32()); break; case 1216: message.confusion_matrix_param = nnabla.ConfusionMatrixParameter.decode(reader, reader.uint32()); break; case 1217: message.vat_noise_param = nnabla.VATNoiseParameter.decode(reader, reader.uint32()); break; case 1219: message.sink_param = nnabla.SinkParameter.decode(reader, reader.uint32()); break; case 1220: message.nms_detection2d_param = nnabla.NmsDetection2dParameter.decode(reader, reader.uint32()); break; case 1221: message.onnx_non_max_suppression_param = nnabla.ONNXNonMaxSuppressionParameter.decode(reader, reader.uint32()); break; case 1222: message.max_pooling_backward_param = nnabla.MaxPoolingBackwardParameter.decode(reader, reader.uint32()); break; case 1223: message.patch_correlation_param = nnabla.PatchCorrelationParameter.decode(reader, reader.uint32()); break; case 1224: message.unique_param = nnabla.UniqueParameter.decode(reader, reader.uint32()); break; case 1225: message.eye_like_param = nnabla.EyeLikeParameter.decode(reader, reader.uint32()); break; case 1226: message.mod2_param = nnabla.Mod2Parameter.decode(reader, reader.uint32()); break; case 1227: message.bit_shift_param = nnabla.BitShiftParameter.decode(reader, reader.uint32()); break; case 1228: message.einsum_param = nnabla.EinsumParameter.decode(reader, reader.uint32()); break; case 100: message.repeat_param = nnabla.RepeatParameter.decode(reader, reader.uint32()); break; case 101: message.recurrent_param = nnabla.RecurrentParameter.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Function(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "name": message.name = reader.string(); break; case "type": message.type = reader.string(); break; case "repeat_id": reader.array(message.repeat_id, () => reader.string()); break; case "context": message.context = nnabla.Context.decodeText(reader); break; case "input": reader.array(message.input, () => reader.string()); break; case "output": reader.array(message.output, () => reader.string()); break; case "affine_param": message.affine_param = nnabla.AffineParameter.decodeText(reader); break; case "rnn_param": message.rnn_param = nnabla.RNNParameter.decodeText(reader); break; case "lstm_param": message.lstm_param = nnabla.LSTMParameter.decodeText(reader); break; case "gru_param": message.gru_param = nnabla.GRUParameter.decodeText(reader); break; case "convolution_param": message.convolution_param = nnabla.ConvolutionParameter.decodeText(reader); break; case "fused_convolution_param": message.fused_convolution_param = nnabla.FusedConvolutionParameter.decodeText(reader); break; case "depthwise_convolution_param": message.depthwise_convolution_param = nnabla.DepthwiseConvolutionParameter.decodeText(reader); break; case "deconvolution_param": message.deconvolution_param = nnabla.DeconvolutionParameter.decodeText(reader); break; case "depthwise_deconvolution_param": message.depthwise_deconvolution_param = nnabla.DepthwiseDeconvolutionParameter.decodeText(reader); break; case "deformable_convolution_param": message.deformable_convolution_param = nnabla.DeformableConvolutionParameter.decodeText(reader); break; case "max_pooling_param": message.max_pooling_param = nnabla.MaxPoolingParameter.decodeText(reader); break; case "average_pooling_param": message.average_pooling_param = nnabla.AveragePoolingParameter.decodeText(reader); break; case "sum_pooling_param": message.sum_pooling_param = nnabla.SumPoolingParameter.decodeText(reader); break; case "unpooling_param": message.unpooling_param = nnabla.UnpoolingParameter.decodeText(reader); break; case "roi_align_param": message.roi_align_param = nnabla.RoiAlignParameter.decodeText(reader); break; case "relu_param": message.relu_param = nnabla.ReLUParameter.decodeText(reader); break; case "leaky_relu_param": message.leaky_relu_param = nnabla.LeakyReLUParameter.decodeText(reader); break; case "softmax_param": message.softmax_param = nnabla.SoftmaxParameter.decodeText(reader); break; case "log_softmax_param": message.log_softmax_param = nnabla.LogSoftmaxParameter.decodeText(reader); break; case "elu_param": message.elu_param = nnabla.ELUParameter.decodeText(reader); break; case "selu_param": message.selu_param = nnabla.SELUParameter.decodeText(reader); break; case "crelu_param": message.crelu_param = nnabla.CReLUParameter.decodeText(reader); break; case "celu_param": message.celu_param = nnabla.CELUParameter.decodeText(reader); break; case "prelu_param": message.prelu_param = nnabla.PReLUParameter.decodeText(reader); break; case "softplus_param": message.softplus_param = nnabla.SoftPlusParameter.decodeText(reader); break; case "fused_batch_normalization_param": message.fused_batch_normalization_param = nnabla.FusedBatchNormalizationParameter.decodeText(reader); break; case "batch_normalization_param": message.batch_normalization_param = nnabla.BatchNormalizationParameter.decodeText(reader); break; case "group_normalization_param": message.group_normalization_param = nnabla.GroupNormalizationParameter.decodeText(reader); break; case "instance_normalization_param": message.instance_normalization_param = nnabla.InstanceNormalizationParameter.decodeText(reader); break; case "layer_normalization_param": message.layer_normalization_param = nnabla.LayerNormalizationParameter.decodeText(reader); break; case "norm_normalization_param": message.norm_normalization_param = nnabla.NormNormalizationParameter.decodeText(reader); break; case "sync_batch_normalization_param": message.sync_batch_normalization_param = nnabla.SyncBatchNormalizationParameter.decodeText(reader); break; case "tensor_normalization_param": message.tensor_normalization_param = nnabla.TensorNormalizationParameter.decodeText(reader); break; case "weight_normalization_param": message.weight_normalization_param = nnabla.WeightNormalizationParameter.decodeText(reader); break; case "weight_standardization_param": message.weight_standardization_param = nnabla.WeightStandardizationParameter.decodeText(reader); break; case "spectral_norm_param": message.spectral_norm_param = nnabla.SpectralNormParameter.decodeText(reader); break; case "mean_subtraction_param": message.mean_subtraction_param = nnabla.MeanSubtractionParameter.decodeText(reader); break; case "clip_grad_by_norm_param": message.clip_grad_by_norm_param = nnabla.ClipGradByNormParameter.decodeText(reader); break; case "sum_param": message.sum_param = nnabla.SumParameter.decodeText(reader); break; case "cumsum_param": message.cumsum_param = nnabla.CumSumParameter.decodeText(reader); break; case "mean_param": message.mean_param = nnabla.MeanParameter.decodeText(reader); break; case "max_param": message.max_param = nnabla.MaxParameter.decodeText(reader); break; case "min_param": message.min_param = nnabla.MinParameter.decodeText(reader); break; case "norm_param": message.norm_param = nnabla.NormParameter.decodeText(reader); break; case "prod_param": message.prod_param = nnabla.ProdParameter.decodeText(reader); break; case "cumprod_param": message.cumprod_param = nnabla.CumProdParameter.decodeText(reader); break; case "add2_param": message.add2_param = nnabla.Add2Parameter.decodeText(reader); break; case "bc_add2_param": message.bc_add2_param = nnabla.BcAdd2Parameter.decodeText(reader); break; case "sub2_param": message.sub2_param = nnabla.Sub2Parameter.decodeText(reader); break; case "mul2_param": message.mul2_param = nnabla.Mul2Parameter.decodeText(reader); break; case "div2_param": message.div2_param = nnabla.Div2Parameter.decodeText(reader); break; case "pow2_param": message.pow2_param = nnabla.Pow2Parameter.decodeText(reader); break; case "add_scalar_param": message.add_scalar_param = nnabla.AddScalarParameter.decodeText(reader); break; case "mul_scalar_param": message.mul_scalar_param = nnabla.MulScalarParameter.decodeText(reader); break; case "pow_scalar_param": message.pow_scalar_param = nnabla.PowScalarParameter.decodeText(reader); break; case "r_sub_scalar_param": message.r_sub_scalar_param = nnabla.RSubScalarParameter.decodeText(reader); break; case "r_div_scalar_param": message.r_div_scalar_param = nnabla.RDivScalarParameter.decodeText(reader); break; case "r_pow_scalar_param": message.r_pow_scalar_param = nnabla.RPowScalarParameter.decodeText(reader); break; case "sign_param": message.sign_param = nnabla.SignParameter.decodeText(reader); break; case "minimum_scalar_param": message.minimum_scalar_param = nnabla.MinimumScalarParameter.decodeText(reader); break; case "maximum_scalar_param": message.maximum_scalar_param = nnabla.MaximumScalarParameter.decodeText(reader); break; case "searchsorted_param": message.searchsorted_param = nnabla.SearchSortedParameter.decodeText(reader); break; case "logical_and_scalar_param": message.logical_and_scalar_param = nnabla.LogicalAndScalarParameter.decodeText(reader); break; case "logical_or_scalar_param": message.logical_or_scalar_param = nnabla.LogicalOrScalarParameter.decodeText(reader); break; case "logical_xor_scalar_param": message.logical_xor_scalar_param = nnabla.LogicalXorScalarParameter.decodeText(reader); break; case "equal_scalar_param": message.equal_scalar_param = nnabla.EqualScalarParameter.decodeText(reader); break; case "not_equal_scalar_param": message.not_equal_scalar_param = nnabla.NotEqualScalarParameter.decodeText(reader); break; case "greater_equal_scalar_param": message.greater_equal_scalar_param = nnabla.GreaterEqualScalarParameter.decodeText(reader); break; case "greater_scalar_param": message.greater_scalar_param = nnabla.GreaterScalarParameter.decodeText(reader); break; case "less_equal_scalar_param": message.less_equal_scalar_param = nnabla.LessEqualScalarParameter.decodeText(reader); break; case "less_scalar_param": message.less_scalar_param = nnabla.LessScalarParameter.decodeText(reader); break; case "reset_nan_param": message.reset_nan_param = nnabla.ResetNaNParameter.decodeText(reader); break; case "reset_inf_param": message.reset_inf_param = nnabla.ResetInfParameter.decodeText(reader); break; case "constant_param": message.constant_param = nnabla.ConstantParameter.decodeText(reader); break; case "arange_param": message.arange_param = nnabla.ArangeParameter.decodeText(reader); break; case "linspace_param": message.linspace_param = nnabla.LinspaceParameter.decodeText(reader); break; case "batch_matmul_param": message.batch_matmul_param = nnabla.BatchMatmulParameter.decodeText(reader); break; case "round_param": message.round_param = nnabla.RoundParameter.decodeText(reader); break; case "ceil_param": message.ceil_param = nnabla.CeilParameter.decodeText(reader); break; case "floor_param": message.floor_param = nnabla.FloorParameter.decodeText(reader); break; case "concatenate_param": message.concatenate_param = nnabla.ConcatenateParameter.decodeText(reader); break; case "split_param": message.split_param = nnabla.SplitParameter.decodeText(reader); break; case "stack_param": message.stack_param = nnabla.StackParameter.decodeText(reader); break; case "slice_param": message.slice_param = nnabla.SliceParameter.decodeText(reader); break; case "pad_param": message.pad_param = nnabla.PadParameter.decodeText(reader); break; case "transpose_param": message.transpose_param = nnabla.TransposeParameter.decodeText(reader); break; case "broadcast_param": message.broadcast_param = nnabla.BroadcastParameter.decodeText(reader); break; case "broadcast_to_param": message.broadcast_to_param = nnabla.BroadcastToParameter.decodeText(reader); break; case "tile_param": message.tile_param = nnabla.TileParameter.decodeText(reader); break; case "one_hot_param": message.one_hot_param = nnabla.OneHotParameter.decodeText(reader); break; case "flip_param": message.flip_param = nnabla.FlipParameter.decodeText(reader); break; case "shift_param": message.shift_param = nnabla.ShiftParameter.decodeText(reader); break; case "sort_param": message.sort_param = nnabla.SortParameter.decodeText(reader); break; case "reshape_param": message.reshape_param = nnabla.ReshapeParameter.decodeText(reader); break; case "shape_param": message.shape_param = nnabla.ShapeParameter.decodeText(reader); break; case "trilu_param": message.trilu_param = nnabla.TriluParameter.decodeText(reader); break; case "meshgrid_param": message.meshgrid_param = nnabla.MeshgridParameter.decodeText(reader); break; case "batch_cholesky_param": message.batch_cholesky_param = nnabla.BatchCholeskyParameter.decodeText(reader); break; case "gather_param": message.gather_param = nnabla.GatherParameter.decodeText(reader); break; case "scatter_nd_param": message.scatter_nd_param = nnabla.ScatterNdParameter.decodeText(reader); break; case "scatter_add_param": message.scatter_add_param = nnabla.ScatterAddParameter.decodeText(reader); break; case "bool_fill_param": message.bool_fill_param = nnabla.BoolFillParameter.decodeText(reader); break; case "pack_padded_sequence_param": message.pack_padded_sequence_param = nnabla.PackPaddedSequenceParameter.decodeText(reader); break; case "pad_packed_sequence_param": message.pad_packed_sequence_param = nnabla.PadPackedSequenceParameter.decodeText(reader); break; case "interpolate_param": message.interpolate_param = nnabla.InterpolateParameter.decodeText(reader); break; case "onnx_resize_param": message.onnx_resize_param = nnabla.ONNXResizeParameter.decodeText(reader); break; case "fft_param": message.fft_param = nnabla.FFTParameter.decodeText(reader); break; case "ifft_param": message.ifft_param = nnabla.IFFTParameter.decodeText(reader); break; case "stft_param": message.stft_param = nnabla.STFTParameter.decodeText(reader); break; case "istft_param": message.istft_param = nnabla.ISTFTParameter.decodeText(reader); break; case "dropout_param": message.dropout_param = nnabla.DropoutParameter.decodeText(reader); break; case "top_k_data_param": message.top_k_data_param = nnabla.TopKDataParameter.decodeText(reader); break; case "top_k_grad_param": message.top_k_grad_param = nnabla.TopKGradParameter.decodeText(reader); break; case "rand_param": message.rand_param = nnabla.RandParameter.decodeText(reader); break; case "randint_param": message.randint_param = nnabla.RandintParameter.decodeText(reader); break; case "randn_param": message.randn_param = nnabla.RandnParameter.decodeText(reader); break; case "rand_binomial_param": message.rand_binomial_param = nnabla.RandBinomialParameter.decodeText(reader); break; case "rand_beta_param": message.rand_beta_param = nnabla.RandBetaParameter.decodeText(reader); break; case "rand_gamma_param": message.rand_gamma_param = nnabla.RandGammaParameter.decodeText(reader); break; case "random_choice_param": message.random_choice_param = nnabla.RandomChoiceParameter.decodeText(reader); break; case "random_crop_param": message.random_crop_param = nnabla.RandomCropParameter.decodeText(reader); break; case "random_flip_param": message.random_flip_param = nnabla.RandomFlipParameter.decodeText(reader); break; case "random_shift_param": message.random_shift_param = nnabla.RandomShiftParameter.decodeText(reader); break; case "random_erase_param": message.random_erase_param = nnabla.RandomEraseParameter.decodeText(reader); break; case "image_augmentation_param": message.image_augmentation_param = nnabla.ImageAugmentationParameter.decodeText(reader); break; case "softmax_cross_entropy_param": message.softmax_cross_entropy_param = nnabla.SoftmaxCrossEntropyParameter.decodeText(reader); break; case "categorical_cross_entropy_param": message.categorical_cross_entropy_param = nnabla.CategoricalCrossEntropyParameter.decodeText(reader); break; case "huber_loss_param": message.huber_loss_param = nnabla.HuberLossParameter.decodeText(reader); break; case "epsilon_insensitive_loss_param": message.epsilon_insensitive_loss_param = nnabla.EpsilonInsensitiveLossParameter.decodeText(reader); break; case "kl_multinomial_param": message.kl_multinomial_param = nnabla.KLMultinomialParameter.decodeText(reader); break; case "affine_grid_param": message.affine_grid_param = nnabla.AffineGridParameter.decodeText(reader); break; case "warp_by_grid_param": message.warp_by_grid_param = nnabla.WarpByGridParameter.decodeText(reader); break; case "binary_connect_affine_param": message.binary_connect_affine_param = nnabla.BinaryConnectAffineParameter.decodeText(reader); break; case "binary_connect_convolution_param": message.binary_connect_convolution_param = nnabla.BinaryConnectConvolutionParameter.decodeText(reader); break; case "binary_weight_affine_param": message.binary_weight_affine_param = nnabla.BinaryWeightAffineParameter.decodeText(reader); break; case "binary_weight_convolution_param": message.binary_weight_convolution_param = nnabla.BinaryWeightConvolutionParameter.decodeText(reader); break; case "inq_affine_param": message.inq_affine_param = nnabla.INQAffineParameter.decodeText(reader); break; case "inq_convolution_param": message.inq_convolution_param = nnabla.INQConvolutionParameter.decodeText(reader); break; case "fixed_point_quantize_param": message.fixed_point_quantize_param = nnabla.FixedPointQuantizeParameter.decodeText(reader); break; case "min_max_quantize_param": message.min_max_quantize_param = nnabla.MinMaxQuantizeParameter.decodeText(reader); break; case "pow2_quantize_param": message.pow2_quantize_param = nnabla.Pow2QuantizeParameter.decodeText(reader); break; case "prune_param": message.prune_param = nnabla.PruneParameter.decodeText(reader); break; case "quantize_linear_param": message.quantize_linear_param = nnabla.QuantizeLinearParameter.decodeText(reader); break; case "top_n_error_param": message.top_n_error_param = nnabla.TopNErrorParameter.decodeText(reader); break; case "confusion_matrix_param": message.confusion_matrix_param = nnabla.ConfusionMatrixParameter.decodeText(reader); break; case "vat_noise_param": message.vat_noise_param = nnabla.VATNoiseParameter.decodeText(reader); break; case "sink_param": message.sink_param = nnabla.SinkParameter.decodeText(reader); break; case "nms_detection2d_param": message.nms_detection2d_param = nnabla.NmsDetection2dParameter.decodeText(reader); break; case "onnx_non_max_suppression_param": message.onnx_non_max_suppression_param = nnabla.ONNXNonMaxSuppressionParameter.decodeText(reader); break; case "max_pooling_backward_param": message.max_pooling_backward_param = nnabla.MaxPoolingBackwardParameter.decodeText(reader); break; case "patch_correlation_param": message.patch_correlation_param = nnabla.PatchCorrelationParameter.decodeText(reader); break; case "unique_param": message.unique_param = nnabla.UniqueParameter.decodeText(reader); break; case "eye_like_param": message.eye_like_param = nnabla.EyeLikeParameter.decodeText(reader); break; case "mod2_param": message.mod2_param = nnabla.Mod2Parameter.decodeText(reader); break; case "bit_shift_param": message.bit_shift_param = nnabla.BitShiftParameter.decodeText(reader); break; case "einsum_param": message.einsum_param = nnabla.EinsumParameter.decodeText(reader); break; case "repeat_param": message.repeat_param = nnabla.RepeatParameter.decodeText(reader); break; case "recurrent_param": message.recurrent_param = nnabla.RecurrentParameter.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Function.prototype.name = ""; nnabla.Function.prototype.type = ""; nnabla.Function.prototype.context = null; nnabla.Function.prototype.repeat_param = null; nnabla.Function.prototype.recurrent_param = null; nnabla.AffineParameter = class AffineParameter { static decode(reader, length) { const message = new nnabla.AffineParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AffineParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AffineParameter.prototype.base_axis = 0n; nnabla.RNNParameter = class RNNParameter { static decode(reader, length) { const message = new nnabla.RNNParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.num_layers = reader.int64(); break; case 2: message.nonlinearity = reader.string(); break; case 3: message.dropout = reader.float(); break; case 4: message.bidirectional = reader.bool(); break; case 5: message.training = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RNNParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "num_layers": message.num_layers = reader.int64(); break; case "nonlinearity": message.nonlinearity = reader.string(); break; case "dropout": message.dropout = reader.float(); break; case "bidirectional": message.bidirectional = reader.bool(); break; case "training": message.training = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RNNParameter.prototype.num_layers = 0n; nnabla.RNNParameter.prototype.nonlinearity = ""; nnabla.RNNParameter.prototype.dropout = 0; nnabla.RNNParameter.prototype.bidirectional = false; nnabla.RNNParameter.prototype.training = false; nnabla.LSTMParameter = class LSTMParameter { static decode(reader, length) { const message = new nnabla.LSTMParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.num_layers = reader.int64(); break; case 2: message.dropout = reader.float(); break; case 3: message.bidirectional = reader.bool(); break; case 4: message.training = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LSTMParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "num_layers": message.num_layers = reader.int64(); break; case "dropout": message.dropout = reader.float(); break; case "bidirectional": message.bidirectional = reader.bool(); break; case "training": message.training = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LSTMParameter.prototype.num_layers = 0n; nnabla.LSTMParameter.prototype.dropout = 0; nnabla.LSTMParameter.prototype.bidirectional = false; nnabla.LSTMParameter.prototype.training = false; nnabla.GRUParameter = class GRUParameter { static decode(reader, length) { const message = new nnabla.GRUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.num_layers = reader.int64(); break; case 2: message.dropout = reader.float(); break; case 3: message.bidirectional = reader.bool(); break; case 4: message.training = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GRUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "num_layers": message.num_layers = reader.int64(); break; case "dropout": message.dropout = reader.float(); break; case "bidirectional": message.bidirectional = reader.bool(); break; case "training": message.training = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GRUParameter.prototype.num_layers = 0n; nnabla.GRUParameter.prototype.dropout = 0; nnabla.GRUParameter.prototype.bidirectional = false; nnabla.GRUParameter.prototype.training = false; nnabla.ConvolutionParameter = class ConvolutionParameter { static decode(reader, length) { const message = new nnabla.ConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ConvolutionParameter.prototype.base_axis = 0n; nnabla.ConvolutionParameter.prototype.pad = null; nnabla.ConvolutionParameter.prototype.stride = null; nnabla.ConvolutionParameter.prototype.dilation = null; nnabla.ConvolutionParameter.prototype.group = 0n; nnabla.ConvolutionParameter.prototype.channel_last = false; nnabla.FusedConvolutionParameter = class FusedConvolutionParameter { constructor() { this.nonlinearity_args = []; } static decode(reader, length) { const message = new nnabla.FusedConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.channel_last = reader.bool(); break; case 7: message.decay_rate = reader.float(); break; case 8: message.eps = reader.float(); break; case 9: message.batch_stat = reader.bool(); break; case 10: message.nonlinearity = reader.string(); break; case 11: message.nonlinearity_args = reader.floats(message.nonlinearity_args, tag); break; case 12: message.pad_mode = reader.string(); break; case 13: message.constant_value = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FusedConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; case "decay_rate": message.decay_rate = reader.float(); break; case "eps": message.eps = reader.float(); break; case "batch_stat": message.batch_stat = reader.bool(); break; case "nonlinearity": message.nonlinearity = reader.string(); break; case "nonlinearity_args": reader.array(message.nonlinearity_args, () => reader.float()); break; case "pad_mode": message.pad_mode = reader.string(); break; case "constant_value": message.constant_value = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.FusedConvolutionParameter.prototype.base_axis = 0n; nnabla.FusedConvolutionParameter.prototype.pad = null; nnabla.FusedConvolutionParameter.prototype.stride = null; nnabla.FusedConvolutionParameter.prototype.dilation = null; nnabla.FusedConvolutionParameter.prototype.group = 0n; nnabla.FusedConvolutionParameter.prototype.channel_last = false; nnabla.FusedConvolutionParameter.prototype.decay_rate = 0; nnabla.FusedConvolutionParameter.prototype.eps = 0; nnabla.FusedConvolutionParameter.prototype.batch_stat = false; nnabla.FusedConvolutionParameter.prototype.nonlinearity = ""; nnabla.FusedConvolutionParameter.prototype.pad_mode = ""; nnabla.FusedConvolutionParameter.prototype.constant_value = 0; nnabla.DepthwiseConvolutionParameter = class DepthwiseConvolutionParameter { static decode(reader, length) { const message = new nnabla.DepthwiseConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.multiplier = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DepthwiseConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "multiplier": message.multiplier = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DepthwiseConvolutionParameter.prototype.base_axis = 0n; nnabla.DepthwiseConvolutionParameter.prototype.pad = null; nnabla.DepthwiseConvolutionParameter.prototype.stride = null; nnabla.DepthwiseConvolutionParameter.prototype.dilation = null; nnabla.DepthwiseConvolutionParameter.prototype.multiplier = 0n; nnabla.DeconvolutionParameter = class DeconvolutionParameter { static decode(reader, length) { const message = new nnabla.DeconvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.channel_last = reader.bool(); break; case 7: message.output_padding = nnabla.Shape.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DeconvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; case "output_padding": message.output_padding = nnabla.Shape.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DeconvolutionParameter.prototype.base_axis = 0n; nnabla.DeconvolutionParameter.prototype.pad = null; nnabla.DeconvolutionParameter.prototype.stride = null; nnabla.DeconvolutionParameter.prototype.dilation = null; nnabla.DeconvolutionParameter.prototype.group = 0n; nnabla.DeconvolutionParameter.prototype.channel_last = false; nnabla.DeconvolutionParameter.prototype.output_padding = null; nnabla.DepthwiseDeconvolutionParameter = class DepthwiseDeconvolutionParameter { static decode(reader, length) { const message = new nnabla.DepthwiseDeconvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.divisor = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DepthwiseDeconvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "divisor": message.divisor = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DepthwiseDeconvolutionParameter.prototype.base_axis = 0n; nnabla.DepthwiseDeconvolutionParameter.prototype.pad = null; nnabla.DepthwiseDeconvolutionParameter.prototype.stride = null; nnabla.DepthwiseDeconvolutionParameter.prototype.dilation = null; nnabla.DepthwiseDeconvolutionParameter.prototype.divisor = 0n; nnabla.DeformableConvolutionParameter = class DeformableConvolutionParameter { static decode(reader, length) { const message = new nnabla.DeformableConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.deformable_group = reader.int64(); break; case 7: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DeformableConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "deformable_group": message.deformable_group = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DeformableConvolutionParameter.prototype.base_axis = 0n; nnabla.DeformableConvolutionParameter.prototype.pad = null; nnabla.DeformableConvolutionParameter.prototype.stride = null; nnabla.DeformableConvolutionParameter.prototype.dilation = null; nnabla.DeformableConvolutionParameter.prototype.group = 0n; nnabla.DeformableConvolutionParameter.prototype.deformable_group = 0n; nnabla.DeformableConvolutionParameter.prototype.channel_last = false; nnabla.MaxPoolingParameter = class MaxPoolingParameter { static decode(reader, length) { const message = new nnabla.MaxPoolingParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.kernel = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.ignore_border = reader.bool(); break; case 4: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MaxPoolingParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "kernel": message.kernel = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "ignore_border": message.ignore_border = reader.bool(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MaxPoolingParameter.prototype.kernel = null; nnabla.MaxPoolingParameter.prototype.stride = null; nnabla.MaxPoolingParameter.prototype.ignore_border = false; nnabla.MaxPoolingParameter.prototype.pad = null; nnabla.MaxPoolingParameter.prototype.channel_last = false; nnabla.AveragePoolingParameter = class AveragePoolingParameter { static decode(reader, length) { const message = new nnabla.AveragePoolingParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.kernel = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.ignore_border = reader.bool(); break; case 4: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.channel_last = reader.bool(); break; case 6: message.including_pad = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AveragePoolingParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "kernel": message.kernel = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "ignore_border": message.ignore_border = reader.bool(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "channel_last": message.channel_last = reader.bool(); break; case "including_pad": message.including_pad = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AveragePoolingParameter.prototype.kernel = null; nnabla.AveragePoolingParameter.prototype.stride = null; nnabla.AveragePoolingParameter.prototype.ignore_border = false; nnabla.AveragePoolingParameter.prototype.pad = null; nnabla.AveragePoolingParameter.prototype.channel_last = false; nnabla.AveragePoolingParameter.prototype.including_pad = false; nnabla.SumPoolingParameter = class SumPoolingParameter { static decode(reader, length) { const message = new nnabla.SumPoolingParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.kernel = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.ignore_border = reader.bool(); break; case 4: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SumPoolingParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "kernel": message.kernel = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "ignore_border": message.ignore_border = reader.bool(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SumPoolingParameter.prototype.kernel = null; nnabla.SumPoolingParameter.prototype.stride = null; nnabla.SumPoolingParameter.prototype.ignore_border = false; nnabla.SumPoolingParameter.prototype.pad = null; nnabla.SumPoolingParameter.prototype.channel_last = false; nnabla.UnpoolingParameter = class UnpoolingParameter { static decode(reader, length) { const message = new nnabla.UnpoolingParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.kernel = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.UnpoolingParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "kernel": message.kernel = nnabla.Shape.decodeText(reader); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.UnpoolingParameter.prototype.kernel = null; nnabla.UnpoolingParameter.prototype.channel_last = false; nnabla.RoiAlignParameter = class RoiAlignParameter { constructor() { this.spatial_scale = []; } static decode(reader, length) { const message = new nnabla.RoiAlignParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.output_size = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.spatial_scale = reader.floats(message.spatial_scale, tag); break; case 3: message.sampling_ratio = reader.int64(); break; case 4: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RoiAlignParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "output_size": message.output_size = nnabla.Shape.decodeText(reader); break; case "spatial_scale": reader.array(message.spatial_scale, () => reader.float()); break; case "sampling_ratio": message.sampling_ratio = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RoiAlignParameter.prototype.output_size = null; nnabla.RoiAlignParameter.prototype.sampling_ratio = 0n; nnabla.RoiAlignParameter.prototype.channel_last = false; nnabla.ReLUParameter = class ReLUParameter { static decode(reader, length) { const message = new nnabla.ReLUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ReLUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ReLUParameter.prototype.inplace = false; nnabla.LeakyReLUParameter = class LeakyReLUParameter { static decode(reader, length) { const message = new nnabla.LeakyReLUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LeakyReLUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LeakyReLUParameter.prototype.alpha = 0; nnabla.LeakyReLUParameter.prototype.inplace = false; nnabla.SoftmaxParameter = class SoftmaxParameter { static decode(reader, length) { const message = new nnabla.SoftmaxParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SoftmaxParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SoftmaxParameter.prototype.axis = 0n; nnabla.LogSoftmaxParameter = class LogSoftmaxParameter { static decode(reader, length) { const message = new nnabla.LogSoftmaxParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LogSoftmaxParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LogSoftmaxParameter.prototype.axis = 0n; nnabla.ELUParameter = class ELUParameter { static decode(reader, length) { const message = new nnabla.ELUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ELUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ELUParameter.prototype.alpha = 0; nnabla.SELUParameter = class SELUParameter { static decode(reader, length) { const message = new nnabla.SELUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.scale = reader.double(); break; case 2: message.alpha = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SELUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "scale": message.scale = reader.double(); break; case "alpha": message.alpha = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SELUParameter.prototype.scale = 0; nnabla.SELUParameter.prototype.alpha = 0; nnabla.CReLUParameter = class CReLUParameter { static decode(reader, length) { const message = new nnabla.CReLUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CReLUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CReLUParameter.prototype.axis = 0n; nnabla.CELUParameter = class CELUParameter { static decode(reader, length) { const message = new nnabla.CELUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.double(); break; case 2: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CELUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.double(); break; case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CELUParameter.prototype.alpha = 0; nnabla.CELUParameter.prototype.axis = 0n; nnabla.PReLUParameter = class PReLUParameter { static decode(reader, length) { const message = new nnabla.PReLUParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PReLUParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PReLUParameter.prototype.base_axis = 0n; nnabla.SoftPlusParameter = class SoftPlusParameter { static decode(reader, length) { const message = new nnabla.SoftPlusParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.beta = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SoftPlusParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "beta": message.beta = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SoftPlusParameter.prototype.beta = 0; nnabla.FusedBatchNormalizationParameter = class FusedBatchNormalizationParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.FusedBatchNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.decay_rate = reader.float(); break; case 3: message.eps = reader.float(); break; case 4: message.batch_stat = reader.bool(); break; case 5: message.nonlinearity = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FusedBatchNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "decay_rate": message.decay_rate = reader.float(); break; case "eps": message.eps = reader.float(); break; case "batch_stat": message.batch_stat = reader.bool(); break; case "nonlinearity": message.nonlinearity = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.FusedBatchNormalizationParameter.prototype.decay_rate = 0; nnabla.FusedBatchNormalizationParameter.prototype.eps = 0; nnabla.FusedBatchNormalizationParameter.prototype.batch_stat = false; nnabla.FusedBatchNormalizationParameter.prototype.nonlinearity = ""; nnabla.BatchNormalizationParameter = class BatchNormalizationParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.BatchNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.decay_rate = reader.float(); break; case 3: message.eps = reader.float(); break; case 4: message.batch_stat = reader.bool(); break; case 5: message.no_scale = reader.bool(); break; case 6: message.no_bias = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BatchNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "decay_rate": message.decay_rate = reader.float(); break; case "eps": message.eps = reader.float(); break; case "batch_stat": message.batch_stat = reader.bool(); break; case "no_scale": message.no_scale = reader.bool(); break; case "no_bias": message.no_bias = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BatchNormalizationParameter.prototype.decay_rate = 0; nnabla.BatchNormalizationParameter.prototype.eps = 0; nnabla.BatchNormalizationParameter.prototype.batch_stat = false; nnabla.BatchNormalizationParameter.prototype.no_scale = false; nnabla.BatchNormalizationParameter.prototype.no_bias = false; nnabla.GroupNormalizationParameter = class GroupNormalizationParameter { constructor() { this.batch_axis = []; } static decode(reader, length) { const message = new nnabla.GroupNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.num_groups = reader.int64(); break; case 2: message.channel_axis = reader.int64(); break; case 3: message.batch_axis = reader.array(message.batch_axis, () => reader.int64(), tag); break; case 4: message.eps = reader.float(); break; case 5: message.no_scale = reader.bool(); break; case 6: message.no_bias = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GroupNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "num_groups": message.num_groups = reader.int64(); break; case "channel_axis": message.channel_axis = reader.int64(); break; case "batch_axis": reader.array(message.batch_axis, () => reader.int64()); break; case "eps": message.eps = reader.float(); break; case "no_scale": message.no_scale = reader.bool(); break; case "no_bias": message.no_bias = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GroupNormalizationParameter.prototype.num_groups = 0n; nnabla.GroupNormalizationParameter.prototype.channel_axis = 0n; nnabla.GroupNormalizationParameter.prototype.eps = 0; nnabla.GroupNormalizationParameter.prototype.no_scale = false; nnabla.GroupNormalizationParameter.prototype.no_bias = false; nnabla.InstanceNormalizationParameter = class InstanceNormalizationParameter { constructor() { this.batch_axis = []; } static decode(reader, length) { const message = new nnabla.InstanceNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.channel_axis = reader.int64(); break; case 2: message.batch_axis = reader.array(message.batch_axis, () => reader.int64(), tag); break; case 3: message.eps = reader.float(); break; case 4: message.no_scale = reader.bool(); break; case 5: message.no_bias = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.InstanceNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "channel_axis": message.channel_axis = reader.int64(); break; case "batch_axis": reader.array(message.batch_axis, () => reader.int64()); break; case "eps": message.eps = reader.float(); break; case "no_scale": message.no_scale = reader.bool(); break; case "no_bias": message.no_bias = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.InstanceNormalizationParameter.prototype.channel_axis = 0n; nnabla.InstanceNormalizationParameter.prototype.eps = 0; nnabla.InstanceNormalizationParameter.prototype.no_scale = false; nnabla.InstanceNormalizationParameter.prototype.no_bias = false; nnabla.LayerNormalizationParameter = class LayerNormalizationParameter { constructor() { this.batch_axis = []; } static decode(reader, length) { const message = new nnabla.LayerNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.batch_axis = reader.array(message.batch_axis, () => reader.int64(), tag); break; case 2: message.eps = reader.float(); break; case 3: message.no_scale = reader.bool(); break; case 4: message.no_bias = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LayerNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "batch_axis": reader.array(message.batch_axis, () => reader.int64()); break; case "eps": message.eps = reader.float(); break; case "no_scale": message.no_scale = reader.bool(); break; case "no_bias": message.no_bias = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LayerNormalizationParameter.prototype.eps = 0; nnabla.LayerNormalizationParameter.prototype.no_scale = false; nnabla.LayerNormalizationParameter.prototype.no_bias = false; nnabla.NormNormalizationParameter = class NormNormalizationParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.NormNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.p = reader.float(); break; case 2: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 3: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NormNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "p": message.p = reader.float(); break; case "axes": reader.array(message.axes, () => reader.int64()); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NormNormalizationParameter.prototype.p = 0; nnabla.NormNormalizationParameter.prototype.eps = 0; nnabla.SyncBatchNormalizationParameter = class SyncBatchNormalizationParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.SyncBatchNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.comm = nnabla.Communicator.decode(reader, reader.uint32()); break; case 2: message.group = reader.string(); break; case 3: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 4: message.decay_rate = reader.float(); break; case 5: message.eps = reader.float(); break; case 6: message.batch_stat = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SyncBatchNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "comm": message.comm = nnabla.Communicator.decodeText(reader); break; case "group": message.group = reader.string(); break; case "axes": reader.array(message.axes, () => reader.int64()); break; case "decay_rate": message.decay_rate = reader.float(); break; case "eps": message.eps = reader.float(); break; case "batch_stat": message.batch_stat = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SyncBatchNormalizationParameter.prototype.comm = null; nnabla.SyncBatchNormalizationParameter.prototype.group = ""; nnabla.SyncBatchNormalizationParameter.prototype.decay_rate = 0; nnabla.SyncBatchNormalizationParameter.prototype.eps = 0; nnabla.SyncBatchNormalizationParameter.prototype.batch_stat = false; nnabla.TensorNormalizationParameter = class TensorNormalizationParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.TensorNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.eps = reader.float(); break; case 3: message.no_scale = reader.bool(); break; case 4: message.no_bias = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TensorNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "eps": message.eps = reader.float(); break; case "no_scale": message.no_scale = reader.bool(); break; case "no_bias": message.no_bias = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TensorNormalizationParameter.prototype.eps = 0; nnabla.TensorNormalizationParameter.prototype.no_scale = false; nnabla.TensorNormalizationParameter.prototype.no_bias = false; nnabla.WeightNormalizationParameter = class WeightNormalizationParameter { static decode(reader, length) { const message = new nnabla.WeightNormalizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.dim = reader.int64(); break; case 2: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.WeightNormalizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "dim": message.dim = reader.int64(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.WeightNormalizationParameter.prototype.dim = 0n; nnabla.WeightNormalizationParameter.prototype.eps = 0; nnabla.WeightStandardizationParameter = class WeightStandardizationParameter { static decode(reader, length) { const message = new nnabla.WeightStandardizationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.channel_axis = reader.int64(); break; case 2: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.WeightStandardizationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "channel_axis": message.channel_axis = reader.int64(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.WeightStandardizationParameter.prototype.channel_axis = 0n; nnabla.WeightStandardizationParameter.prototype.eps = 0; nnabla.SpectralNormParameter = class SpectralNormParameter { static decode(reader, length) { const message = new nnabla.SpectralNormParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.dim = reader.int64(); break; case 2: message.itr = reader.int64(); break; case 3: message.eps = reader.float(); break; case 4: message.test = reader.bool(); break; case 5: message.output_u = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SpectralNormParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "dim": message.dim = reader.int64(); break; case "itr": message.itr = reader.int64(); break; case "eps": message.eps = reader.float(); break; case "test": message.test = reader.bool(); break; case "output_u": message.output_u = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SpectralNormParameter.prototype.dim = 0n; nnabla.SpectralNormParameter.prototype.itr = 0n; nnabla.SpectralNormParameter.prototype.eps = 0; nnabla.SpectralNormParameter.prototype.test = false; nnabla.SpectralNormParameter.prototype.output_u = false; nnabla.MeanSubtractionParameter = class MeanSubtractionParameter { static decode(reader, length) { const message = new nnabla.MeanSubtractionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.update_running_mean = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MeanSubtractionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "update_running_mean": message.update_running_mean = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MeanSubtractionParameter.prototype.base_axis = 0n; nnabla.MeanSubtractionParameter.prototype.update_running_mean = false; nnabla.ClipGradByNormParameter = class ClipGradByNormParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.ClipGradByNormParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.clip_norm = reader.float(); break; case 2: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ClipGradByNormParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "clip_norm": message.clip_norm = reader.float(); break; case "axes": reader.array(message.axes, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ClipGradByNormParameter.prototype.clip_norm = 0; nnabla.SumParameter = class SumParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.SumParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.keep_dims = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SumParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SumParameter.prototype.keep_dims = false; nnabla.CumSumParameter = class CumSumParameter { static decode(reader, length) { const message = new nnabla.CumSumParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; case 2: message.exclusive = reader.bool(); break; case 3: message.reverse = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CumSumParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; case "exclusive": message.exclusive = reader.bool(); break; case "reverse": message.reverse = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CumSumParameter.prototype.axis = 0n; nnabla.CumSumParameter.prototype.exclusive = false; nnabla.CumSumParameter.prototype.reverse = false; nnabla.MeanParameter = class MeanParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.MeanParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.keep_dims = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MeanParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MeanParameter.prototype.keep_dims = false; nnabla.MaxParameter = class MaxParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.MaxParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.keep_dims = reader.bool(); break; case 3: message.with_index = reader.bool(); break; case 4: message.only_index = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MaxParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; case "with_index": message.with_index = reader.bool(); break; case "only_index": message.only_index = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MaxParameter.prototype.keep_dims = false; nnabla.MaxParameter.prototype.with_index = false; nnabla.MaxParameter.prototype.only_index = false; nnabla.MinParameter = class MinParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.MinParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.keep_dims = reader.bool(); break; case 3: message.with_index = reader.bool(); break; case 4: message.only_index = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MinParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; case "with_index": message.with_index = reader.bool(); break; case "only_index": message.only_index = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MinParameter.prototype.keep_dims = false; nnabla.MinParameter.prototype.with_index = false; nnabla.MinParameter.prototype.only_index = false; nnabla.NormParameter = class NormParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.NormParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.p = reader.float(); break; case 2: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 3: message.keep_dims = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NormParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "p": message.p = reader.float(); break; case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NormParameter.prototype.p = 0; nnabla.NormParameter.prototype.keep_dims = false; nnabla.ProdParameter = class ProdParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.ProdParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.keep_dims = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ProdParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "keep_dims": message.keep_dims = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ProdParameter.prototype.keep_dims = false; nnabla.CumProdParameter = class CumProdParameter { static decode(reader, length) { const message = new nnabla.CumProdParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; case 2: message.exclusive = reader.bool(); break; case 3: message.reverse = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CumProdParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; case "exclusive": message.exclusive = reader.bool(); break; case "reverse": message.reverse = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CumProdParameter.prototype.axis = 0n; nnabla.CumProdParameter.prototype.exclusive = false; nnabla.CumProdParameter.prototype.reverse = false; nnabla.Add2Parameter = class Add2Parameter { static decode(reader, length) { const message = new nnabla.Add2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Add2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Add2Parameter.prototype.inplace = false; nnabla.BcAdd2Parameter = class BcAdd2Parameter { static decode(reader, length) { const message = new nnabla.BcAdd2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BcAdd2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BcAdd2Parameter.prototype.inplace = false; nnabla.Sub2Parameter = class Sub2Parameter { static decode(reader, length) { const message = new nnabla.Sub2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Sub2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Sub2Parameter.prototype.inplace = false; nnabla.Mul2Parameter = class Mul2Parameter { static decode(reader, length) { const message = new nnabla.Mul2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Mul2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Mul2Parameter.prototype.inplace = false; nnabla.Div2Parameter = class Div2Parameter { static decode(reader, length) { const message = new nnabla.Div2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Div2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Div2Parameter.prototype.inplace = false; nnabla.Pow2Parameter = class Pow2Parameter { static decode(reader, length) { const message = new nnabla.Pow2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Pow2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Pow2Parameter.prototype.inplace = false; nnabla.AddScalarParameter = class AddScalarParameter { static decode(reader, length) { const message = new nnabla.AddScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; case 2: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AddScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AddScalarParameter.prototype.val = 0; nnabla.AddScalarParameter.prototype.inplace = false; nnabla.MulScalarParameter = class MulScalarParameter { static decode(reader, length) { const message = new nnabla.MulScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; case 2: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MulScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MulScalarParameter.prototype.val = 0; nnabla.MulScalarParameter.prototype.inplace = false; nnabla.PowScalarParameter = class PowScalarParameter { static decode(reader, length) { const message = new nnabla.PowScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; case 2: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PowScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PowScalarParameter.prototype.val = 0; nnabla.PowScalarParameter.prototype.inplace = false; nnabla.RSubScalarParameter = class RSubScalarParameter { static decode(reader, length) { const message = new nnabla.RSubScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RSubScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RSubScalarParameter.prototype.val = 0; nnabla.RDivScalarParameter = class RDivScalarParameter { static decode(reader, length) { const message = new nnabla.RDivScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RDivScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RDivScalarParameter.prototype.val = 0; nnabla.RPowScalarParameter = class RPowScalarParameter { static decode(reader, length) { const message = new nnabla.RPowScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RPowScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RPowScalarParameter.prototype.val = 0; nnabla.SignParameter = class SignParameter { static decode(reader, length) { const message = new nnabla.SignParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SignParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SignParameter.prototype.alpha = 0; nnabla.MinimumScalarParameter = class MinimumScalarParameter { static decode(reader, length) { const message = new nnabla.MinimumScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MinimumScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MinimumScalarParameter.prototype.val = 0; nnabla.MaximumScalarParameter = class MaximumScalarParameter { static decode(reader, length) { const message = new nnabla.MaximumScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MaximumScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MaximumScalarParameter.prototype.val = 0; nnabla.SearchSortedParameter = class SearchSortedParameter { static decode(reader, length) { const message = new nnabla.SearchSortedParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.right = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SearchSortedParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "right": message.right = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SearchSortedParameter.prototype.right = false; nnabla.LogicalAndScalarParameter = class LogicalAndScalarParameter { static decode(reader, length) { const message = new nnabla.LogicalAndScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LogicalAndScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LogicalAndScalarParameter.prototype.val = false; nnabla.LogicalOrScalarParameter = class LogicalOrScalarParameter { static decode(reader, length) { const message = new nnabla.LogicalOrScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LogicalOrScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LogicalOrScalarParameter.prototype.val = false; nnabla.LogicalXorScalarParameter = class LogicalXorScalarParameter { static decode(reader, length) { const message = new nnabla.LogicalXorScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LogicalXorScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LogicalXorScalarParameter.prototype.val = false; nnabla.EqualScalarParameter = class EqualScalarParameter { static decode(reader, length) { const message = new nnabla.EqualScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.EqualScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.EqualScalarParameter.prototype.val = 0; nnabla.NotEqualScalarParameter = class NotEqualScalarParameter { static decode(reader, length) { const message = new nnabla.NotEqualScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NotEqualScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NotEqualScalarParameter.prototype.val = 0; nnabla.GreaterEqualScalarParameter = class GreaterEqualScalarParameter { static decode(reader, length) { const message = new nnabla.GreaterEqualScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GreaterEqualScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GreaterEqualScalarParameter.prototype.val = 0; nnabla.GreaterScalarParameter = class GreaterScalarParameter { static decode(reader, length) { const message = new nnabla.GreaterScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GreaterScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GreaterScalarParameter.prototype.val = 0; nnabla.LessEqualScalarParameter = class LessEqualScalarParameter { static decode(reader, length) { const message = new nnabla.LessEqualScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LessEqualScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LessEqualScalarParameter.prototype.val = 0; nnabla.LessScalarParameter = class LessScalarParameter { static decode(reader, length) { const message = new nnabla.LessScalarParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LessScalarParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LessScalarParameter.prototype.val = 0; nnabla.ResetNaNParameter = class ResetNaNParameter { static decode(reader, length) { const message = new nnabla.ResetNaNParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ResetNaNParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ResetNaNParameter.prototype.val = 0; nnabla.ResetInfParameter = class ResetInfParameter { static decode(reader, length) { const message = new nnabla.ResetInfParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.double(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ResetInfParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.double(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ResetInfParameter.prototype.val = 0; nnabla.ConstantParameter = class ConstantParameter { static decode(reader, length) { const message = new nnabla.ConstantParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.val = reader.float(); break; case 2: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ConstantParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "val": message.val = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ConstantParameter.prototype.val = 0; nnabla.ConstantParameter.prototype.shape = null; nnabla.ArangeParameter = class ArangeParameter { static decode(reader, length) { const message = new nnabla.ArangeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.start = reader.float(); break; case 2: message.stop = reader.float(); break; case 3: message.step = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ArangeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "start": message.start = reader.float(); break; case "stop": message.stop = reader.float(); break; case "step": message.step = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ArangeParameter.prototype.start = 0; nnabla.ArangeParameter.prototype.stop = 0; nnabla.ArangeParameter.prototype.step = 0; nnabla.LinspaceParameter = class LinspaceParameter { static decode(reader, length) { const message = new nnabla.LinspaceParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.start = reader.float(); break; case 2: message.stop = reader.float(); break; case 3: message.num = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.LinspaceParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "start": message.start = reader.float(); break; case "stop": message.stop = reader.float(); break; case "num": message.num = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.LinspaceParameter.prototype.start = 0; nnabla.LinspaceParameter.prototype.stop = 0; nnabla.LinspaceParameter.prototype.num = 0n; nnabla.BatchMatmulParameter = class BatchMatmulParameter { static decode(reader, length) { const message = new nnabla.BatchMatmulParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.transpose_a = reader.bool(); break; case 2: message.transpose_b = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BatchMatmulParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "transpose_a": message.transpose_a = reader.bool(); break; case "transpose_b": message.transpose_b = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BatchMatmulParameter.prototype.transpose_a = false; nnabla.BatchMatmulParameter.prototype.transpose_b = false; nnabla.RoundParameter = class RoundParameter { static decode(reader, length) { const message = new nnabla.RoundParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RoundParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { default: reader.field(tag, message); break; } } return message; } }; nnabla.CeilParameter = class CeilParameter { static decode(reader, length) { const message = new nnabla.CeilParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CeilParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { default: reader.field(tag, message); break; } } return message; } }; nnabla.FloorParameter = class FloorParameter { static decode(reader, length) { const message = new nnabla.FloorParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FloorParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { default: reader.field(tag, message); break; } } return message; } }; nnabla.ConcatenateParameter = class ConcatenateParameter { static decode(reader, length) { const message = new nnabla.ConcatenateParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ConcatenateParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ConcatenateParameter.prototype.axis = 0n; nnabla.SplitParameter = class SplitParameter { static decode(reader, length) { const message = new nnabla.SplitParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SplitParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SplitParameter.prototype.axis = 0n; nnabla.StackParameter = class StackParameter { static decode(reader, length) { const message = new nnabla.StackParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.StackParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.StackParameter.prototype.axis = 0n; nnabla.SliceParameter = class SliceParameter { constructor() { this.start = []; this.stop = []; this.step = []; } static decode(reader, length) { const message = new nnabla.SliceParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.start = reader.array(message.start, () => reader.int64(), tag); break; case 2: message.stop = reader.array(message.stop, () => reader.int64(), tag); break; case 3: message.step = reader.array(message.step, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SliceParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "start": reader.array(message.start, () => reader.int64()); break; case "stop": reader.array(message.stop, () => reader.int64()); break; case "step": reader.array(message.step, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PadParameter = class PadParameter { constructor() { this.pad_width = []; } static decode(reader, length) { const message = new nnabla.PadParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.pad_width = reader.array(message.pad_width, () => reader.int64(), tag); break; case 2: message.mode = reader.string(); break; case 3: message.constant_value = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PadParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "pad_width": reader.array(message.pad_width, () => reader.int64()); break; case "mode": message.mode = reader.string(); break; case "constant_value": message.constant_value = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PadParameter.prototype.mode = ""; nnabla.PadParameter.prototype.constant_value = 0; nnabla.TransposeParameter = class TransposeParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.TransposeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TransposeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BroadcastParameter = class BroadcastParameter { static decode(reader, length) { const message = new nnabla.BroadcastParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BroadcastParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BroadcastParameter.prototype.shape = null; nnabla.BroadcastToParameter = class BroadcastToParameter { static decode(reader, length) { const message = new nnabla.BroadcastToParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BroadcastToParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BroadcastToParameter.prototype.axis = 0n; nnabla.TileParameter = class TileParameter { constructor() { this.reps = []; } static decode(reader, length) { const message = new nnabla.TileParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.reps = reader.array(message.reps, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TileParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "reps": reader.array(message.reps, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.OneHotParameter = class OneHotParameter { static decode(reader, length) { const message = new nnabla.OneHotParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.OneHotParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.OneHotParameter.prototype.shape = null; nnabla.FlipParameter = class FlipParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.FlipParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FlipParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ShiftParameter = class ShiftParameter { constructor() { this.shifts = []; } static decode(reader, length) { const message = new nnabla.ShiftParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shifts = reader.array(message.shifts, () => reader.int64(), tag); break; case 2: message.border_mode = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ShiftParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shifts": reader.array(message.shifts, () => reader.int64()); break; case "border_mode": message.border_mode = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ShiftParameter.prototype.border_mode = ""; nnabla.SortParameter = class SortParameter { static decode(reader, length) { const message = new nnabla.SortParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; case 2: message.reverse = reader.bool(); break; case 3: message.with_index = reader.bool(); break; case 4: message.only_index = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SortParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; case "reverse": message.reverse = reader.bool(); break; case "with_index": message.with_index = reader.bool(); break; case "only_index": message.only_index = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SortParameter.prototype.axis = 0n; nnabla.SortParameter.prototype.reverse = false; nnabla.SortParameter.prototype.with_index = false; nnabla.SortParameter.prototype.only_index = false; nnabla.ReshapeParameter = class ReshapeParameter { static decode(reader, length) { const message = new nnabla.ReshapeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.inplace = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ReshapeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "inplace": message.inplace = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ReshapeParameter.prototype.shape = null; nnabla.ReshapeParameter.prototype.inplace = false; nnabla.ShapeParameter = class ShapeParameter { static decode(reader, length) { const message = new nnabla.ShapeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.start = reader.int64(); break; case 2: message.end = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ShapeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "start": message.start = reader.int64(); break; case "end": message.end = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ShapeParameter.prototype.start = 0n; nnabla.ShapeParameter.prototype.end = 0n; nnabla.TriluParameter = class TriluParameter { static decode(reader, length) { const message = new nnabla.TriluParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.k = reader.int64(); break; case 2: message.upper = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TriluParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "k": message.k = reader.int64(); break; case "upper": message.upper = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TriluParameter.prototype.k = 0n; nnabla.TriluParameter.prototype.upper = false; nnabla.MeshgridParameter = class MeshgridParameter { static decode(reader, length) { const message = new nnabla.MeshgridParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.ij_indexing = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MeshgridParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "ij_indexing": message.ij_indexing = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MeshgridParameter.prototype.ij_indexing = false; nnabla.BatchCholeskyParameter = class BatchCholeskyParameter { static decode(reader, length) { const message = new nnabla.BatchCholeskyParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.upper = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BatchCholeskyParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "upper": message.upper = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BatchCholeskyParameter.prototype.upper = false; nnabla.GatherParameter = class GatherParameter { static decode(reader, length) { const message = new nnabla.GatherParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; case 2: message.batch_dims = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.GatherParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; case "batch_dims": message.batch_dims = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.GatherParameter.prototype.axis = 0n; nnabla.GatherParameter.prototype.batch_dims = 0n; nnabla.ScatterNdParameter = class ScatterNdParameter { constructor() { this.shape = []; } static decode(reader, length) { const message = new nnabla.ScatterNdParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = reader.array(message.shape, () => reader.int64(), tag); break; case 2: message.add = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ScatterNdParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": reader.array(message.shape, () => reader.int64()); break; case "add": message.add = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ScatterNdParameter.prototype.add = false; nnabla.ScatterAddParameter = class ScatterAddParameter { static decode(reader, length) { const message = new nnabla.ScatterAddParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ScatterAddParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ScatterAddParameter.prototype.axis = 0n; nnabla.BoolFillParameter = class BoolFillParameter { static decode(reader, length) { const message = new nnabla.BoolFillParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.value = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BoolFillParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "value": message.value = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BoolFillParameter.prototype.value = 0; nnabla.PackPaddedSequenceParameter = class PackPaddedSequenceParameter { static decode(reader, length) { const message = new nnabla.PackPaddedSequenceParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.batch_first = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PackPaddedSequenceParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "batch_first": message.batch_first = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PackPaddedSequenceParameter.prototype.batch_first = false; nnabla.PadPackedSequenceParameter = class PadPackedSequenceParameter { static decode(reader, length) { const message = new nnabla.PadPackedSequenceParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.batch_first = reader.bool(); break; case 2: message.padding_value = reader.float(); break; case 3: message.total_length = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PadPackedSequenceParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "batch_first": message.batch_first = reader.bool(); break; case "padding_value": message.padding_value = reader.float(); break; case "total_length": message.total_length = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PadPackedSequenceParameter.prototype.batch_first = false; nnabla.PadPackedSequenceParameter.prototype.padding_value = 0; nnabla.PadPackedSequenceParameter.prototype.total_length = 0n; nnabla.InterpolateParameter = class InterpolateParameter { constructor() { this.output_size = []; } static decode(reader, length) { const message = new nnabla.InterpolateParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.output_size = reader.array(message.output_size, () => reader.int64(), tag); break; case 2: message.mode = reader.string(); break; case 3: message.align_corners = reader.bool(); break; case 4: message.half_pixel = reader.bool(); break; case 5: message.half_pixel_for_nn = reader.bool(); break; case 6: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.InterpolateParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "output_size": reader.array(message.output_size, () => reader.int64()); break; case "mode": message.mode = reader.string(); break; case "align_corners": message.align_corners = reader.bool(); break; case "half_pixel": message.half_pixel = reader.bool(); break; case "half_pixel_for_nn": message.half_pixel_for_nn = reader.bool(); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.InterpolateParameter.prototype.mode = ""; nnabla.InterpolateParameter.prototype.align_corners = false; nnabla.InterpolateParameter.prototype.half_pixel = false; nnabla.InterpolateParameter.prototype.half_pixel_for_nn = false; nnabla.InterpolateParameter.prototype.channel_last = false; nnabla.ONNXResizeParameter = class ONNXResizeParameter { constructor() { this.roi = []; this.scales = []; this.sizes = []; } static decode(reader, length) { const message = new nnabla.ONNXResizeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.roi = reader.floats(message.roi, tag); break; case 2: message.scales = reader.floats(message.scales, tag); break; case 3: message.sizes = reader.array(message.sizes, () => reader.int64(), tag); break; case 4: message.mode = reader.string(); break; case 5: message.coordinate_transformation_mode = reader.string(); break; case 6: message.cubic_coeff_a = reader.float(); break; case 7: message.exclude_outside = reader.int64(); break; case 8: message.extrapolation_value = reader.float(); break; case 9: message.nearest_mode = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ONNXResizeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "roi": reader.array(message.roi, () => reader.float()); break; case "scales": reader.array(message.scales, () => reader.float()); break; case "sizes": reader.array(message.sizes, () => reader.int64()); break; case "mode": message.mode = reader.string(); break; case "coordinate_transformation_mode": message.coordinate_transformation_mode = reader.string(); break; case "cubic_coeff_a": message.cubic_coeff_a = reader.float(); break; case "exclude_outside": message.exclude_outside = reader.int64(); break; case "extrapolation_value": message.extrapolation_value = reader.float(); break; case "nearest_mode": message.nearest_mode = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ONNXResizeParameter.prototype.mode = ""; nnabla.ONNXResizeParameter.prototype.coordinate_transformation_mode = ""; nnabla.ONNXResizeParameter.prototype.cubic_coeff_a = 0; nnabla.ONNXResizeParameter.prototype.exclude_outside = 0n; nnabla.ONNXResizeParameter.prototype.extrapolation_value = 0; nnabla.ONNXResizeParameter.prototype.nearest_mode = ""; nnabla.FFTParameter = class FFTParameter { static decode(reader, length) { const message = new nnabla.FFTParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.signal_ndim = reader.int64(); break; case 2: message.normalized = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FFTParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "signal_ndim": message.signal_ndim = reader.int64(); break; case "normalized": message.normalized = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.FFTParameter.prototype.signal_ndim = 0n; nnabla.FFTParameter.prototype.normalized = false; nnabla.IFFTParameter = class IFFTParameter { static decode(reader, length) { const message = new nnabla.IFFTParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.signal_ndim = reader.int64(); break; case 2: message.normalized = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.IFFTParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "signal_ndim": message.signal_ndim = reader.int64(); break; case "normalized": message.normalized = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.IFFTParameter.prototype.signal_ndim = 0n; nnabla.IFFTParameter.prototype.normalized = false; nnabla.STFTParameter = class STFTParameter { static decode(reader, length) { const message = new nnabla.STFTParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.window_size = reader.int64(); break; case 2: message.stride = reader.int64(); break; case 3: message.fft_size = reader.int64(); break; case 4: message.window_type = reader.string(); break; case 5: message.center = reader.bool(); break; case 6: message.pad_mode = reader.string(); break; case 7: message.as_istft_backward = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.STFTParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "window_size": message.window_size = reader.int64(); break; case "stride": message.stride = reader.int64(); break; case "fft_size": message.fft_size = reader.int64(); break; case "window_type": message.window_type = reader.string(); break; case "center": message.center = reader.bool(); break; case "pad_mode": message.pad_mode = reader.string(); break; case "as_istft_backward": message.as_istft_backward = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.STFTParameter.prototype.window_size = 0n; nnabla.STFTParameter.prototype.stride = 0n; nnabla.STFTParameter.prototype.fft_size = 0n; nnabla.STFTParameter.prototype.window_type = ""; nnabla.STFTParameter.prototype.center = false; nnabla.STFTParameter.prototype.pad_mode = ""; nnabla.STFTParameter.prototype.as_istft_backward = false; nnabla.ISTFTParameter = class ISTFTParameter { static decode(reader, length) { const message = new nnabla.ISTFTParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.window_size = reader.int64(); break; case 2: message.stride = reader.int64(); break; case 3: message.fft_size = reader.int64(); break; case 4: message.window_type = reader.string(); break; case 5: message.center = reader.bool(); break; case 6: message.pad_mode = reader.string(); break; case 7: message.as_stft_backward = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ISTFTParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "window_size": message.window_size = reader.int64(); break; case "stride": message.stride = reader.int64(); break; case "fft_size": message.fft_size = reader.int64(); break; case "window_type": message.window_type = reader.string(); break; case "center": message.center = reader.bool(); break; case "pad_mode": message.pad_mode = reader.string(); break; case "as_stft_backward": message.as_stft_backward = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ISTFTParameter.prototype.window_size = 0n; nnabla.ISTFTParameter.prototype.stride = 0n; nnabla.ISTFTParameter.prototype.fft_size = 0n; nnabla.ISTFTParameter.prototype.window_type = ""; nnabla.ISTFTParameter.prototype.center = false; nnabla.ISTFTParameter.prototype.pad_mode = ""; nnabla.ISTFTParameter.prototype.as_stft_backward = false; nnabla.DropoutParameter = class DropoutParameter { static decode(reader, length) { const message = new nnabla.DropoutParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.p = reader.double(); break; case 2: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.DropoutParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "p": message.p = reader.double(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.DropoutParameter.prototype.p = 0; nnabla.DropoutParameter.prototype.seed = 0n; nnabla.TopKDataParameter = class TopKDataParameter { static decode(reader, length) { const message = new nnabla.TopKDataParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.k = reader.int64(); break; case 2: message.abs = reader.bool(); break; case 3: message.reduce = reader.bool(); break; case 4: message.base_axis = reader.int64(); break; case 5: message.largest = reader.bool(); break; case 6: message.with_index = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TopKDataParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "k": message.k = reader.int64(); break; case "abs": message.abs = reader.bool(); break; case "reduce": message.reduce = reader.bool(); break; case "base_axis": message.base_axis = reader.int64(); break; case "largest": message.largest = reader.bool(); break; case "with_index": message.with_index = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TopKDataParameter.prototype.k = 0n; nnabla.TopKDataParameter.prototype.abs = false; nnabla.TopKDataParameter.prototype.reduce = false; nnabla.TopKDataParameter.prototype.base_axis = 0n; nnabla.TopKDataParameter.prototype.largest = false; nnabla.TopKDataParameter.prototype.with_index = false; nnabla.TopKGradParameter = class TopKGradParameter { static decode(reader, length) { const message = new nnabla.TopKGradParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.k = reader.int64(); break; case 2: message.abs = reader.bool(); break; case 3: message.base_axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TopKGradParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "k": message.k = reader.int64(); break; case "abs": message.abs = reader.bool(); break; case "base_axis": message.base_axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TopKGradParameter.prototype.k = 0n; nnabla.TopKGradParameter.prototype.abs = false; nnabla.TopKGradParameter.prototype.base_axis = 0n; nnabla.RandParameter = class RandParameter { static decode(reader, length) { const message = new nnabla.RandParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.low = reader.float(); break; case 2: message.high = reader.float(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "low": message.low = reader.float(); break; case "high": message.high = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandParameter.prototype.low = 0; nnabla.RandParameter.prototype.high = 0; nnabla.RandParameter.prototype.shape = null; nnabla.RandParameter.prototype.seed = 0n; nnabla.RandintParameter = class RandintParameter { static decode(reader, length) { const message = new nnabla.RandintParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.low = reader.int64(); break; case 2: message.high = reader.int64(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandintParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "low": message.low = reader.int64(); break; case "high": message.high = reader.int64(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandintParameter.prototype.low = 0n; nnabla.RandintParameter.prototype.high = 0n; nnabla.RandintParameter.prototype.shape = null; nnabla.RandintParameter.prototype.seed = 0n; nnabla.RandnParameter = class RandnParameter { static decode(reader, length) { const message = new nnabla.RandnParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.mu = reader.float(); break; case 2: message.sigma = reader.float(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandnParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "mu": message.mu = reader.float(); break; case "sigma": message.sigma = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandnParameter.prototype.mu = 0; nnabla.RandnParameter.prototype.sigma = 0; nnabla.RandnParameter.prototype.shape = null; nnabla.RandnParameter.prototype.seed = 0n; nnabla.RandBinomialParameter = class RandBinomialParameter { static decode(reader, length) { const message = new nnabla.RandBinomialParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.n = reader.int64(); break; case 2: message.p = reader.float(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandBinomialParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "n": message.n = reader.int64(); break; case "p": message.p = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandBinomialParameter.prototype.n = 0n; nnabla.RandBinomialParameter.prototype.p = 0; nnabla.RandBinomialParameter.prototype.shape = null; nnabla.RandBinomialParameter.prototype.seed = 0n; nnabla.RandBetaParameter = class RandBetaParameter { static decode(reader, length) { const message = new nnabla.RandBetaParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.alpha = reader.float(); break; case 2: message.beta = reader.float(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandBetaParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "alpha": message.alpha = reader.float(); break; case "beta": message.beta = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandBetaParameter.prototype.alpha = 0; nnabla.RandBetaParameter.prototype.beta = 0; nnabla.RandBetaParameter.prototype.shape = null; nnabla.RandBetaParameter.prototype.seed = 0n; nnabla.RandGammaParameter = class RandGammaParameter { static decode(reader, length) { const message = new nnabla.RandGammaParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.k = reader.float(); break; case 2: message.theta = reader.float(); break; case 3: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandGammaParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "k": message.k = reader.float(); break; case "theta": message.theta = reader.float(); break; case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandGammaParameter.prototype.k = 0; nnabla.RandGammaParameter.prototype.theta = 0; nnabla.RandGammaParameter.prototype.shape = null; nnabla.RandGammaParameter.prototype.seed = 0n; nnabla.RandomChoiceParameter = class RandomChoiceParameter { static decode(reader, length) { const message = new nnabla.RandomChoiceParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.replace = reader.bool(); break; case 3: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandomChoiceParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "replace": message.replace = reader.bool(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandomChoiceParameter.prototype.shape = null; nnabla.RandomChoiceParameter.prototype.replace = false; nnabla.RandomChoiceParameter.prototype.seed = 0n; nnabla.RandomCropParameter = class RandomCropParameter { static decode(reader, length) { const message = new nnabla.RandomCropParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.base_axis = reader.int64(); break; case 3: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandomCropParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "base_axis": message.base_axis = reader.int64(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandomCropParameter.prototype.shape = null; nnabla.RandomCropParameter.prototype.base_axis = 0n; nnabla.RandomCropParameter.prototype.seed = 0n; nnabla.RandomFlipParameter = class RandomFlipParameter { constructor() { this.axes = []; } static decode(reader, length) { const message = new nnabla.RandomFlipParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axes = reader.array(message.axes, () => reader.int64(), tag); break; case 2: message.base_axis = reader.int64(); break; case 3: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandomFlipParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axes": reader.array(message.axes, () => reader.int64()); break; case "base_axis": message.base_axis = reader.int64(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandomFlipParameter.prototype.base_axis = 0n; nnabla.RandomFlipParameter.prototype.seed = 0n; nnabla.RandomShiftParameter = class RandomShiftParameter { constructor() { this.shifts = []; } static decode(reader, length) { const message = new nnabla.RandomShiftParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shifts = reader.array(message.shifts, () => reader.int64(), tag); break; case 2: message.border_mode = reader.string(); break; case 3: message.constant_value = reader.float(); break; case 4: message.base_axis = reader.int64(); break; case 5: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandomShiftParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shifts": reader.array(message.shifts, () => reader.int64()); break; case "border_mode": message.border_mode = reader.string(); break; case "constant_value": message.constant_value = reader.float(); break; case "base_axis": message.base_axis = reader.int64(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandomShiftParameter.prototype.border_mode = ""; nnabla.RandomShiftParameter.prototype.constant_value = 0; nnabla.RandomShiftParameter.prototype.base_axis = 0n; nnabla.RandomShiftParameter.prototype.seed = 0n; nnabla.RandomEraseParameter = class RandomEraseParameter { constructor() { this.area_ratios = []; this.aspect_ratios = []; this.replacements = []; } static decode(reader, length) { const message = new nnabla.RandomEraseParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.prob = reader.float(); break; case 2: message.area_ratios = reader.floats(message.area_ratios, tag); break; case 3: message.aspect_ratios = reader.floats(message.aspect_ratios, tag); break; case 4: message.replacements = reader.floats(message.replacements, tag); break; case 5: message.n = reader.int64(); break; case 6: message.share = reader.bool(); break; case 7: message.inplace = reader.bool(); break; case 8: message.base_axis = reader.int64(); break; case 9: message.seed = reader.int64(); break; case 10: message.channel_last = reader.bool(); break; case 11: message.ste_fine_grained = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.RandomEraseParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "prob": message.prob = reader.float(); break; case "area_ratios": reader.array(message.area_ratios, () => reader.float()); break; case "aspect_ratios": reader.array(message.aspect_ratios, () => reader.float()); break; case "replacements": reader.array(message.replacements, () => reader.float()); break; case "n": message.n = reader.int64(); break; case "share": message.share = reader.bool(); break; case "inplace": message.inplace = reader.bool(); break; case "base_axis": message.base_axis = reader.int64(); break; case "seed": message.seed = reader.int64(); break; case "channel_last": message.channel_last = reader.bool(); break; case "ste_fine_grained": message.ste_fine_grained = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.RandomEraseParameter.prototype.prob = 0; nnabla.RandomEraseParameter.prototype.n = 0n; nnabla.RandomEraseParameter.prototype.share = false; nnabla.RandomEraseParameter.prototype.inplace = false; nnabla.RandomEraseParameter.prototype.base_axis = 0n; nnabla.RandomEraseParameter.prototype.seed = 0n; nnabla.RandomEraseParameter.prototype.channel_last = false; nnabla.RandomEraseParameter.prototype.ste_fine_grained = false; nnabla.ImageAugmentationParameter = class ImageAugmentationParameter { static decode(reader, length) { const message = new nnabla.ImageAugmentationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.shape = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.min_scale = reader.float(); break; case 4: message.max_scale = reader.float(); break; case 5: message.angle = reader.float(); break; case 6: message.aspect_ratio = reader.float(); break; case 7: message.distortion = reader.float(); break; case 8: message.flip_lr = reader.bool(); break; case 9: message.flip_ud = reader.bool(); break; case 10: message.brightness = reader.float(); break; case 11: message.brightness_each = reader.bool(); break; case 12: message.contrast = reader.float(); break; case 13: message.contrast_center = reader.float(); break; case 14: message.contrast_each = reader.bool(); break; case 15: message.noise = reader.float(); break; case 16: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ImageAugmentationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "shape": message.shape = nnabla.Shape.decodeText(reader); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "min_scale": message.min_scale = reader.float(); break; case "max_scale": message.max_scale = reader.float(); break; case "angle": message.angle = reader.float(); break; case "aspect_ratio": message.aspect_ratio = reader.float(); break; case "distortion": message.distortion = reader.float(); break; case "flip_lr": message.flip_lr = reader.bool(); break; case "flip_ud": message.flip_ud = reader.bool(); break; case "brightness": message.brightness = reader.float(); break; case "brightness_each": message.brightness_each = reader.bool(); break; case "contrast": message.contrast = reader.float(); break; case "contrast_center": message.contrast_center = reader.float(); break; case "contrast_each": message.contrast_each = reader.bool(); break; case "noise": message.noise = reader.float(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ImageAugmentationParameter.prototype.shape = null; nnabla.ImageAugmentationParameter.prototype.pad = null; nnabla.ImageAugmentationParameter.prototype.min_scale = 0; nnabla.ImageAugmentationParameter.prototype.max_scale = 0; nnabla.ImageAugmentationParameter.prototype.angle = 0; nnabla.ImageAugmentationParameter.prototype.aspect_ratio = 0; nnabla.ImageAugmentationParameter.prototype.distortion = 0; nnabla.ImageAugmentationParameter.prototype.flip_lr = false; nnabla.ImageAugmentationParameter.prototype.flip_ud = false; nnabla.ImageAugmentationParameter.prototype.brightness = 0; nnabla.ImageAugmentationParameter.prototype.brightness_each = false; nnabla.ImageAugmentationParameter.prototype.contrast = 0; nnabla.ImageAugmentationParameter.prototype.contrast_center = 0; nnabla.ImageAugmentationParameter.prototype.contrast_each = false; nnabla.ImageAugmentationParameter.prototype.noise = 0; nnabla.ImageAugmentationParameter.prototype.seed = 0n; nnabla.SoftmaxCrossEntropyParameter = class SoftmaxCrossEntropyParameter { static decode(reader, length) { const message = new nnabla.SoftmaxCrossEntropyParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SoftmaxCrossEntropyParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SoftmaxCrossEntropyParameter.prototype.axis = 0n; nnabla.CategoricalCrossEntropyParameter = class CategoricalCrossEntropyParameter { static decode(reader, length) { const message = new nnabla.CategoricalCrossEntropyParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.CategoricalCrossEntropyParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.CategoricalCrossEntropyParameter.prototype.axis = 0n; nnabla.HuberLossParameter = class HuberLossParameter { static decode(reader, length) { const message = new nnabla.HuberLossParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.delta = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.HuberLossParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "delta": message.delta = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.HuberLossParameter.prototype.delta = 0; nnabla.EpsilonInsensitiveLossParameter = class EpsilonInsensitiveLossParameter { static decode(reader, length) { const message = new nnabla.EpsilonInsensitiveLossParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.epsilon = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.EpsilonInsensitiveLossParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "epsilon": message.epsilon = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.EpsilonInsensitiveLossParameter.prototype.epsilon = 0; nnabla.KLMultinomialParameter = class KLMultinomialParameter { static decode(reader, length) { const message = new nnabla.KLMultinomialParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.KLMultinomialParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.KLMultinomialParameter.prototype.base_axis = 0n; nnabla.AffineGridParameter = class AffineGridParameter { constructor() { this.size = []; } static decode(reader, length) { const message = new nnabla.AffineGridParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.size = reader.array(message.size, () => reader.int64(), tag); break; case 2: message.align_corners = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.AffineGridParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "size": reader.array(message.size, () => reader.int64()); break; case "align_corners": message.align_corners = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.AffineGridParameter.prototype.align_corners = false; nnabla.WarpByGridParameter = class WarpByGridParameter { static decode(reader, length) { const message = new nnabla.WarpByGridParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.mode = reader.string(); break; case 2: message.padding_mode = reader.string(); break; case 3: message.align_corners = reader.bool(); break; case 4: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.WarpByGridParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "mode": message.mode = reader.string(); break; case "padding_mode": message.padding_mode = reader.string(); break; case "align_corners": message.align_corners = reader.bool(); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.WarpByGridParameter.prototype.mode = ""; nnabla.WarpByGridParameter.prototype.padding_mode = ""; nnabla.WarpByGridParameter.prototype.align_corners = false; nnabla.WarpByGridParameter.prototype.channel_last = false; nnabla.BinaryConnectAffineParameter = class BinaryConnectAffineParameter { static decode(reader, length) { const message = new nnabla.BinaryConnectAffineParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.quantize_zero_to = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BinaryConnectAffineParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "quantize_zero_to": message.quantize_zero_to = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BinaryConnectAffineParameter.prototype.base_axis = 0n; nnabla.BinaryConnectAffineParameter.prototype.quantize_zero_to = 0; nnabla.BinaryConnectConvolutionParameter = class BinaryConnectConvolutionParameter { static decode(reader, length) { const message = new nnabla.BinaryConnectConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.quantize_zero_to = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BinaryConnectConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "quantize_zero_to": message.quantize_zero_to = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BinaryConnectConvolutionParameter.prototype.base_axis = 0n; nnabla.BinaryConnectConvolutionParameter.prototype.pad = null; nnabla.BinaryConnectConvolutionParameter.prototype.stride = null; nnabla.BinaryConnectConvolutionParameter.prototype.dilation = null; nnabla.BinaryConnectConvolutionParameter.prototype.group = 0n; nnabla.BinaryConnectConvolutionParameter.prototype.quantize_zero_to = 0; nnabla.BinaryWeightAffineParameter = class BinaryWeightAffineParameter { static decode(reader, length) { const message = new nnabla.BinaryWeightAffineParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.quantize_zero_to = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BinaryWeightAffineParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "quantize_zero_to": message.quantize_zero_to = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BinaryWeightAffineParameter.prototype.base_axis = 0n; nnabla.BinaryWeightAffineParameter.prototype.quantize_zero_to = 0; nnabla.BinaryWeightConvolutionParameter = class BinaryWeightConvolutionParameter { static decode(reader, length) { const message = new nnabla.BinaryWeightConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.quantize_zero_to = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BinaryWeightConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "quantize_zero_to": message.quantize_zero_to = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BinaryWeightConvolutionParameter.prototype.base_axis = 0n; nnabla.BinaryWeightConvolutionParameter.prototype.pad = null; nnabla.BinaryWeightConvolutionParameter.prototype.stride = null; nnabla.BinaryWeightConvolutionParameter.prototype.dilation = null; nnabla.BinaryWeightConvolutionParameter.prototype.group = 0n; nnabla.BinaryWeightConvolutionParameter.prototype.quantize_zero_to = 0; nnabla.INQAffineParameter = class INQAffineParameter { constructor() { this.inq_iterations = []; } static decode(reader, length) { const message = new nnabla.INQAffineParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.num_bits = reader.int64(); break; case 3: message.inq_iterations = reader.array(message.inq_iterations, () => reader.int64(), tag); break; case 4: message.selection_algorithm = reader.string(); break; case 5: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.INQAffineParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "num_bits": message.num_bits = reader.int64(); break; case "inq_iterations": reader.array(message.inq_iterations, () => reader.int64()); break; case "selection_algorithm": message.selection_algorithm = reader.string(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.INQAffineParameter.prototype.base_axis = 0n; nnabla.INQAffineParameter.prototype.num_bits = 0n; nnabla.INQAffineParameter.prototype.selection_algorithm = ""; nnabla.INQAffineParameter.prototype.seed = 0n; nnabla.INQConvolutionParameter = class INQConvolutionParameter { constructor() { this.inq_iterations = []; } static decode(reader, length) { const message = new nnabla.INQConvolutionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.dilation = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.group = reader.int64(); break; case 6: message.num_bits = reader.int64(); break; case 7: message.inq_iterations = reader.array(message.inq_iterations, () => reader.int64(), tag); break; case 8: message.selection_algorithm = reader.string(); break; case 9: message.seed = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.INQConvolutionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "dilation": message.dilation = nnabla.Shape.decodeText(reader); break; case "group": message.group = reader.int64(); break; case "num_bits": message.num_bits = reader.int64(); break; case "inq_iterations": reader.array(message.inq_iterations, () => reader.int64()); break; case "selection_algorithm": message.selection_algorithm = reader.string(); break; case "seed": message.seed = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.INQConvolutionParameter.prototype.base_axis = 0n; nnabla.INQConvolutionParameter.prototype.pad = null; nnabla.INQConvolutionParameter.prototype.stride = null; nnabla.INQConvolutionParameter.prototype.dilation = null; nnabla.INQConvolutionParameter.prototype.group = 0n; nnabla.INQConvolutionParameter.prototype.num_bits = 0n; nnabla.INQConvolutionParameter.prototype.selection_algorithm = ""; nnabla.INQConvolutionParameter.prototype.seed = 0n; nnabla.FixedPointQuantizeParameter = class FixedPointQuantizeParameter { static decode(reader, length) { const message = new nnabla.FixedPointQuantizeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.sign = reader.bool(); break; case 2: message.n = reader.int64(); break; case 3: message.delta = reader.float(); break; case 4: message.ste_fine_grained = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.FixedPointQuantizeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "sign": message.sign = reader.bool(); break; case "n": message.n = reader.int64(); break; case "delta": message.delta = reader.float(); break; case "ste_fine_grained": message.ste_fine_grained = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.FixedPointQuantizeParameter.prototype.sign = false; nnabla.FixedPointQuantizeParameter.prototype.n = 0n; nnabla.FixedPointQuantizeParameter.prototype.delta = 0; nnabla.FixedPointQuantizeParameter.prototype.ste_fine_grained = false; nnabla.MinMaxQuantizeParameter = class MinMaxQuantizeParameter { static decode(reader, length) { const message = new nnabla.MinMaxQuantizeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.decay = reader.float(); break; case 2: message.x_min_max = reader.bool(); break; case 3: message.ema = reader.bool(); break; case 4: message.ste_fine_grained = reader.bool(); break; case 5: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MinMaxQuantizeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "decay": message.decay = reader.float(); break; case "x_min_max": message.x_min_max = reader.bool(); break; case "ema": message.ema = reader.bool(); break; case "ste_fine_grained": message.ste_fine_grained = reader.bool(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MinMaxQuantizeParameter.prototype.decay = 0; nnabla.MinMaxQuantizeParameter.prototype.x_min_max = false; nnabla.MinMaxQuantizeParameter.prototype.ema = false; nnabla.MinMaxQuantizeParameter.prototype.ste_fine_grained = false; nnabla.MinMaxQuantizeParameter.prototype.eps = 0; nnabla.Pow2QuantizeParameter = class Pow2QuantizeParameter { static decode(reader, length) { const message = new nnabla.Pow2QuantizeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.sign = reader.bool(); break; case 2: message.with_zero = reader.bool(); break; case 3: message.n = reader.int64(); break; case 4: message.m = reader.int64(); break; case 5: message.ste_fine_grained = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Pow2QuantizeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "sign": message.sign = reader.bool(); break; case "with_zero": message.with_zero = reader.bool(); break; case "n": message.n = reader.int64(); break; case "m": message.m = reader.int64(); break; case "ste_fine_grained": message.ste_fine_grained = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Pow2QuantizeParameter.prototype.sign = false; nnabla.Pow2QuantizeParameter.prototype.with_zero = false; nnabla.Pow2QuantizeParameter.prototype.n = 0n; nnabla.Pow2QuantizeParameter.prototype.m = 0n; nnabla.Pow2QuantizeParameter.prototype.ste_fine_grained = false; nnabla.PruneParameter = class PruneParameter { static decode(reader, length) { const message = new nnabla.PruneParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.rate = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PruneParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "rate": message.rate = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PruneParameter.prototype.rate = 0; nnabla.QuantizeLinearParameter = class QuantizeLinearParameter { static decode(reader, length) { const message = new nnabla.QuantizeLinearParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.round_mode = reader.string(); break; case 2: message.narrow_range = reader.bool(); break; case 3: message.dtype = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.QuantizeLinearParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "round_mode": message.round_mode = reader.string(); break; case "narrow_range": message.narrow_range = reader.bool(); break; case "dtype": message.dtype = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.QuantizeLinearParameter.prototype.round_mode = ""; nnabla.QuantizeLinearParameter.prototype.narrow_range = false; nnabla.QuantizeLinearParameter.prototype.dtype = 0n; nnabla.TopNErrorParameter = class TopNErrorParameter { static decode(reader, length) { const message = new nnabla.TopNErrorParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; case 2: message.n = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.TopNErrorParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; case "n": message.n = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.TopNErrorParameter.prototype.axis = 0n; nnabla.TopNErrorParameter.prototype.n = 0n; nnabla.ConfusionMatrixParameter = class ConfusionMatrixParameter { static decode(reader, length) { const message = new nnabla.ConfusionMatrixParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.axis = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ConfusionMatrixParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "axis": message.axis = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ConfusionMatrixParameter.prototype.axis = 0n; nnabla.VATNoiseParameter = class VATNoiseParameter { static decode(reader, length) { const message = new nnabla.VATNoiseParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.base_axis = reader.int64(); break; case 2: message.eps = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.VATNoiseParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "base_axis": message.base_axis = reader.int64(); break; case "eps": message.eps = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.VATNoiseParameter.prototype.base_axis = 0n; nnabla.VATNoiseParameter.prototype.eps = 0; nnabla.SinkParameter = class SinkParameter { static decode(reader, length) { const message = new nnabla.SinkParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.one_input_grad = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.SinkParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "one_input_grad": message.one_input_grad = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.SinkParameter.prototype.one_input_grad = false; nnabla.NmsDetection2dParameter = class NmsDetection2dParameter { static decode(reader, length) { const message = new nnabla.NmsDetection2dParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.thresh = reader.float(); break; case 2: message.nms = reader.float(); break; case 3: message.nms_per_class = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.NmsDetection2dParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "thresh": message.thresh = reader.float(); break; case "nms": message.nms = reader.float(); break; case "nms_per_class": message.nms_per_class = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.NmsDetection2dParameter.prototype.thresh = 0; nnabla.NmsDetection2dParameter.prototype.nms = 0; nnabla.NmsDetection2dParameter.prototype.nms_per_class = false; nnabla.ONNXNonMaxSuppressionParameter = class ONNXNonMaxSuppressionParameter { static decode(reader, length) { const message = new nnabla.ONNXNonMaxSuppressionParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.center_point_box = reader.int64(); break; case 2: message.max_output_boxes_per_class = reader.int64(); break; case 3: message.iou_threshold = reader.float(); break; case 4: message.score_threshold = reader.float(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.ONNXNonMaxSuppressionParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "center_point_box": message.center_point_box = reader.int64(); break; case "max_output_boxes_per_class": message.max_output_boxes_per_class = reader.int64(); break; case "iou_threshold": message.iou_threshold = reader.float(); break; case "score_threshold": message.score_threshold = reader.float(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.ONNXNonMaxSuppressionParameter.prototype.center_point_box = 0n; nnabla.ONNXNonMaxSuppressionParameter.prototype.max_output_boxes_per_class = 0n; nnabla.ONNXNonMaxSuppressionParameter.prototype.iou_threshold = 0; nnabla.ONNXNonMaxSuppressionParameter.prototype.score_threshold = 0; nnabla.MaxPoolingBackwardParameter = class MaxPoolingBackwardParameter { static decode(reader, length) { const message = new nnabla.MaxPoolingBackwardParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.kernel = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.stride = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.ignore_border = reader.bool(); break; case 4: message.pad = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.channel_last = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.MaxPoolingBackwardParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "kernel": message.kernel = nnabla.Shape.decodeText(reader); break; case "stride": message.stride = nnabla.Shape.decodeText(reader); break; case "ignore_border": message.ignore_border = reader.bool(); break; case "pad": message.pad = nnabla.Shape.decodeText(reader); break; case "channel_last": message.channel_last = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.MaxPoolingBackwardParameter.prototype.kernel = null; nnabla.MaxPoolingBackwardParameter.prototype.stride = null; nnabla.MaxPoolingBackwardParameter.prototype.ignore_border = false; nnabla.MaxPoolingBackwardParameter.prototype.pad = null; nnabla.MaxPoolingBackwardParameter.prototype.channel_last = false; nnabla.PatchCorrelationParameter = class PatchCorrelationParameter { static decode(reader, length) { const message = new nnabla.PatchCorrelationParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.patch = nnabla.Shape.decode(reader, reader.uint32()); break; case 2: message.shift = nnabla.Shape.decode(reader, reader.uint32()); break; case 3: message.patch_step = nnabla.Shape.decode(reader, reader.uint32()); break; case 4: message.shift_step = nnabla.Shape.decode(reader, reader.uint32()); break; case 5: message.padding = nnabla.Shape.decode(reader, reader.uint32()); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.PatchCorrelationParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "patch": message.patch = nnabla.Shape.decodeText(reader); break; case "shift": message.shift = nnabla.Shape.decodeText(reader); break; case "patch_step": message.patch_step = nnabla.Shape.decodeText(reader); break; case "shift_step": message.shift_step = nnabla.Shape.decodeText(reader); break; case "padding": message.padding = nnabla.Shape.decodeText(reader); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.PatchCorrelationParameter.prototype.patch = null; nnabla.PatchCorrelationParameter.prototype.shift = null; nnabla.PatchCorrelationParameter.prototype.patch_step = null; nnabla.PatchCorrelationParameter.prototype.shift_step = null; nnabla.PatchCorrelationParameter.prototype.padding = null; nnabla.UniqueParameter = class UniqueParameter { static decode(reader, length) { const message = new nnabla.UniqueParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.flatten = reader.bool(); break; case 2: message.axis = reader.int64(); break; case 3: message.sorted = reader.bool(); break; case 4: message.with_index = reader.bool(); break; case 5: message.with_inverse = reader.bool(); break; case 6: message.with_counts = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.UniqueParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "flatten": message.flatten = reader.bool(); break; case "axis": message.axis = reader.int64(); break; case "sorted": message.sorted = reader.bool(); break; case "with_index": message.with_index = reader.bool(); break; case "with_inverse": message.with_inverse = reader.bool(); break; case "with_counts": message.with_counts = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.UniqueParameter.prototype.flatten = false; nnabla.UniqueParameter.prototype.axis = 0n; nnabla.UniqueParameter.prototype.sorted = false; nnabla.UniqueParameter.prototype.with_index = false; nnabla.UniqueParameter.prototype.with_inverse = false; nnabla.UniqueParameter.prototype.with_counts = false; nnabla.EyeLikeParameter = class EyeLikeParameter { static decode(reader, length) { const message = new nnabla.EyeLikeParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.k = reader.int64(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.EyeLikeParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "k": message.k = reader.int64(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.EyeLikeParameter.prototype.k = 0n; nnabla.Mod2Parameter = class Mod2Parameter { static decode(reader, length) { const message = new nnabla.Mod2Parameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.fmod = reader.bool(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.Mod2Parameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "fmod": message.fmod = reader.bool(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.Mod2Parameter.prototype.fmod = false; nnabla.BitShiftParameter = class BitShiftParameter { static decode(reader, length) { const message = new nnabla.BitShiftParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.direction = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.BitShiftParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "direction": message.direction = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.BitShiftParameter.prototype.direction = ""; nnabla.EinsumParameter = class EinsumParameter { static decode(reader, length) { const message = new nnabla.EinsumParameter(); const end = length === undefined ? reader.length : reader.position + length; while (reader.position < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: message.equation = reader.string(); break; default: reader.skipType(tag & 7); break; } } return message; } static decodeText(reader) { const message = new nnabla.EinsumParameter(); reader.start(); while (!reader.end()) { const tag = reader.tag(); switch (tag) { case "equation": message.equation = reader.string(); break; default: reader.field(tag, message); break; } } return message; } }; nnabla.EinsumParameter.prototype.equation = "";