def _test_repeat(): print '\n------------------------------------------------------------' print 'Test: dlx.util.theano_utils.repeat' x2 = TU.tensor(2, 'x2') x3 = TU.tensor(3, 'x3') y3 = TU.repeat(x2, 10) y4 = TU.repeat(x3, 10) print P.pprint(y3) print P.pprint(y4)
def _test_tensor(): print '\n------------------------------------------------------------' print 'Test: dlx.util.theano_utils.tensor' x0 = TU.tensor(0, 'x0') x1 = TU.tensor(1, 'x1') x2 = TU.tensor(2, 'x2') x3 = TU.tensor(3, 'x3') x4 = TU.tensor(4, 'x4') print x0, type(x0) print x1, type(x1) print x2, type(x2) print x3, type(x3) print x4, type(x4)
def build(self): self.X = TU.tensor(self.input_dim, name=self.name)
def compile(self, optimizer, loss_configures, verbose = 0): '''Configure the learning process. # Arguments optimizer: str (name of optimizer) or optimizer object. See [optimizers](optimizers.md). loss_configures: list of tuples: (output name, objective function, mask name, weighted, class_mode) weighted: true or false. If true, must provide class_weight or sample_weight in same order. objective function can be string name of objective function or function or None(for output without calculate loss). class_mode: one of "categorical", "binary", None. ''' self.optimizer = optimizers.get(optimizer) self.loss_configures = loss_configures self.input_order = self.input_names self.train_output_order = [] self.predict_output_order = [] self.weight_order = [] self.out_labels = ['loss',] if verbose: print 'input units:', self.input_units print 'output units:', self.output_units print 'hidden units:', self.hidden_units units = self.input_units + self.output_units + self.hidden_units for unit in units: unit.check() for unit in units: unit.build() self.params = [] self.regularizers = [] self.constraints = [] self.updates = [] for unit in self.hidden_units: pars = unit.get_params() self.params += pars[0] self.regularizers += pars[1] self.constraints += pars[2] self.updates += pars[3] if verbose: print 'parameters:', [TU.sp(param) for param in self.params] print 'regularizers:', self.regularizers print 'constraints:', self.constraints print 'updates:', self.updates outputs_train = [] outputs_test = [] ys_test = [] for output_unit, output_name_list in zip(self.output_units, self.output_names): res_train = standardize_l(output_unit.get_results(train=True)) if len(output_name_list) != len(res_train): raise Exception('Number of outputs(train) not match number of names (%s)'%str(output_name_list)) res_test = standardize_l(output_unit.get_results(train=False)) if len(output_name_list) != len(res_test): raise Exception('Number of outputs(test) not match number of names (%s)'%str(output_name_list)) outputs_train.append(res_train) outputs_test.append(res_test) ys_test += res_test self.predict_output_order += output_name_list if verbose: print 'output names:', self.output_names print 'outputs train:', outputs_train print 'outputs test:', outputs_test if verbose >= 2: for vares, names in zip(outputs_train, self.output_names): for var,name in zip(vares, names): if verbose == 2: print 'output_' + name + ':', TU.sp(var) else: print 'output_' + name, ':' TU.dp(var) def find_output(output_name, train): if train: outputs = outputs_train else: outputs = outputs_test for output_list, output_name_list in zip(outputs, self.output_names): for output, name in zip(output_list, output_name_list): if output_name == name: return output raise Exception('Can not find output "%s".'%output_name) ys = [] ys_train = [] train_accs = [] test_accs = [] weights = [] train_loss = 0. test_loss = 0. for loss_cf in loss_configures: output_name = loss_cf[0] obj_fn = loss_cf[1] mask_name = loss_cf[2] weighted = loss_cf[3] class_mode = loss_cf[4] y_train = find_output(output_name, train=True) y_test = find_output(output_name ,train=False) if mask_name: mask_train = find_output(mask_name, train=True) mask_test = find_output(mask_name, train=False) else: mask_train = None mask_test = None y = TU.tensor(ndim=K.ndim(y_train), name=output_name) ys.append(y) ys_train.append(y_train) self.train_output_order.append(output_name) if obj_fn: if weighted: self.weight_order += output_name weight = TU.tensor(1, name=output_name+'_weight') weights.append(weight) weighted_loss = weighted_objective(objectives.get(obj_fn)) train_loss += weighted_loss(y, y_train, weight, mask_train) test_loss += weighted_loss(y, y_test, weight, mask_test) else: weighted_loss = weighted_objective(objectives.get(obj_fn)) train_loss += weighted_loss(y, y_train, None, mask_train) test_loss += weighted_loss(y, y_test, None, mask_test) if class_mode: self.out_labels.append('acc_'+output_name) if class_mode == "categorical": weighted_accuracy = weighted_objective(categorical_accuracy) train_accuracy = weighted_accuracy(y, y_train, None, mask_train) test_accuracy = weighted_accuracy(y, y_test, None, mask_test) elif class_mode == "binary": weighted_accuracy = weighted_objective(binary_accuracy) train_accuracy = weighted_accuracy(y, y_train, None, mask_train) test_accuracy = weighted_accuracy(y, y_test, None, mask_test) else: raise Exception("Invalid class mode:" + str(class_mode)) train_accs.append(train_accuracy) test_accs.append(test_accuracy) if verbose: print 'ys:', ys print 'ys_train:', ys_train print 'predict output order:', self.predict_output_order print 'ys_test:', ys_test print 'train output order:', self.train_output_order print 'train_accs:', train_accs print 'test_accs:', test_accs print 'weight:', weights if verbose == 2: print 'train_loss:', TU.sp(train_loss) print 'test_loss:', TU.sp(test_loss) if verbose >= 3: print 'train_loss:' TU.dp(train_loss) print 'test_loss:' TU.dp(test_loss) ins = [] for input_unit in self.input_units: ins.append(input_unit.get_variable()) if verbose: print 'ins:', ins train_vars = ins + ys + weights test_vars = ins + ys + weights for r in self.regularizers: train_loss = r(train_loss) updates = self.optimizer.get_updates(self.params, self.constraints, train_loss) state_updates = self.updates updates += state_updates if verbose: print 'train_vars:', train_vars print 'test_vars:', test_vars if verbose: print 'updates:' for update in updates: print update self._train = K.function(train_vars, [train_loss], updates=updates) self._train_with_acc = K.function(train_vars, [train_loss] + train_accs, updates=updates) self._test = K.function(test_vars, [test_loss], updates=state_updates) self._test_with_acc = K.function(test_vars, [test_loss] + test_accs, updates=state_updates) self._predict = K.function(inputs=ins, outputs=ys_test, updates=state_updates)
def compile(self, optimizer, loss_configures, verbose=0): '''Configure the learning process. # Arguments optimizer: str (name of optimizer) or optimizer object. See [optimizers](optimizers.md). loss_configures: list of tuples: (output name, objective function, mask name, weighted, class_mode) weighted: true or false. If true, must provide class_weight or sample_weight in same order. objective function can be string name of objective function or function or None(for output without calculate loss). class_mode: one of "categorical", "binary", None. ''' self.optimizer = optimizers.get(optimizer) self.loss_configures = loss_configures self.input_order = self.input_names self.train_output_order = [] self.predict_output_order = [] self.weight_order = [] self.out_labels = [ 'loss', ] if verbose: print 'input units:', self.input_units print 'output units:', self.output_units print 'hidden units:', self.hidden_units units = self.input_units + self.output_units + self.hidden_units for unit in units: unit.check() for unit in units: unit.build() self.params = [] self.regularizers = [] self.constraints = [] self.updates = [] for unit in self.hidden_units: pars = unit.get_params() self.params += pars[0] self.regularizers += pars[1] self.constraints += pars[2] self.updates += pars[3] if verbose: print 'parameters:', [TU.sp(param) for param in self.params] print 'regularizers:', self.regularizers print 'constraints:', self.constraints print 'updates:', self.updates outputs_train = [] outputs_test = [] ys_test = [] for output_unit, output_name_list in zip(self.output_units, self.output_names): res_train = standardize_l(output_unit.get_results(train=True)) if len(output_name_list) != len(res_train): raise Exception( 'Number of outputs(train) not match number of names (%s)' % str(output_name_list)) res_test = standardize_l(output_unit.get_results(train=False)) if len(output_name_list) != len(res_test): raise Exception( 'Number of outputs(test) not match number of names (%s)' % str(output_name_list)) outputs_train.append(res_train) outputs_test.append(res_test) ys_test += res_test self.predict_output_order += output_name_list if verbose: print 'output names:', self.output_names print 'outputs train:', outputs_train print 'outputs test:', outputs_test if verbose >= 2: for vares, names in zip(outputs_train, self.output_names): for var, name in zip(vares, names): if verbose == 2: print 'output_' + name + ':', TU.sp(var) else: print 'output_' + name, ':' TU.dp(var) def find_output(output_name, train): if train: outputs = outputs_train else: outputs = outputs_test for output_list, output_name_list in zip(outputs, self.output_names): for output, name in zip(output_list, output_name_list): if output_name == name: return output raise Exception('Can not find output "%s".' % output_name) ys = [] ys_train = [] train_accs = [] test_accs = [] weights = [] train_loss = 0. test_loss = 0. for loss_cf in loss_configures: output_name = loss_cf[0] obj_fn = loss_cf[1] mask_name = loss_cf[2] weighted = loss_cf[3] class_mode = loss_cf[4] y_train = find_output(output_name, train=True) y_test = find_output(output_name, train=False) if mask_name: mask_train = find_output(mask_name, train=True) mask_test = find_output(mask_name, train=False) else: mask_train = None mask_test = None y = TU.tensor(ndim=K.ndim(y_train), name=output_name) ys.append(y) ys_train.append(y_train) self.train_output_order.append(output_name) if obj_fn: if weighted: self.weight_order += output_name weight = TU.tensor(1, name=output_name + '_weight') weights.append(weight) weighted_loss = weighted_objective(objectives.get(obj_fn)) train_loss += weighted_loss(y, y_train, weight, mask_train) test_loss += weighted_loss(y, y_test, weight, mask_test) else: weighted_loss = weighted_objective(objectives.get(obj_fn)) train_loss += weighted_loss(y, y_train, None, mask_train) test_loss += weighted_loss(y, y_test, None, mask_test) if class_mode: self.out_labels.append('acc_' + output_name) if class_mode == "categorical": weighted_accuracy = weighted_objective( categorical_accuracy) train_accuracy = weighted_accuracy(y, y_train, None, mask_train) test_accuracy = weighted_accuracy(y, y_test, None, mask_test) elif class_mode == "binary": weighted_accuracy = weighted_objective(binary_accuracy) train_accuracy = weighted_accuracy(y, y_train, None, mask_train) test_accuracy = weighted_accuracy(y, y_test, None, mask_test) else: raise Exception("Invalid class mode:" + str(class_mode)) train_accs.append(train_accuracy) test_accs.append(test_accuracy) if verbose: print 'ys:', ys print 'ys_train:', ys_train print 'predict output order:', self.predict_output_order print 'ys_test:', ys_test print 'train output order:', self.train_output_order print 'train_accs:', train_accs print 'test_accs:', test_accs print 'weight:', weights if verbose == 2: print 'train_loss:', TU.sp(train_loss) print 'test_loss:', TU.sp(test_loss) if verbose >= 3: print 'train_loss:' TU.dp(train_loss) print 'test_loss:' TU.dp(test_loss) ins = [] for input_unit in self.input_units: ins.append(input_unit.get_variable()) if verbose: print 'ins:', ins train_vars = ins + ys + weights test_vars = ins + ys + weights for r in self.regularizers: train_loss = r(train_loss) updates = self.optimizer.get_updates(self.params, self.constraints, train_loss) state_updates = self.updates updates += state_updates if verbose: print 'train_vars:', train_vars print 'test_vars:', test_vars if verbose: print 'updates:' for update in updates: print update self._train = K.function(train_vars, [train_loss], updates=updates) self._train_with_acc = K.function(train_vars, [train_loss] + train_accs, updates=updates) self._test = K.function(test_vars, [test_loss], updates=state_updates) self._test_with_acc = K.function(test_vars, [test_loss] + test_accs, updates=state_updates) self._predict = K.function(inputs=ins, outputs=ys_test, updates=state_updates)