from nuronet2.base import MLModel, NetworkModel, NeuralNetwork if __name__ == "__main__": #fName = "/home/evander/Dropbox/data/iris/iris.data" fName = "C:\\Users\\Evander\\Dropbox\\data\\iris\\iris.data" data = IrisDataset(f_name=fName, batch_size=8, validation=0.1) model = NeuralNetwork() model.add(DenseLayer(16, activation="tanh2", input_shape=(3, ))) model.add(DenseLayer(3, activation="softmax")) model.compile('rmsprop', "categorical_crossentropy", metrics=['accuracy']) model.fit_generator(data, steps_per_epoch=17, n_epochs=20, n_workers=4, validation_data=data, validation_steps=5) test = numpy.argmax(model.predict(data.x_test), axis=1) real = data.y_test.nonzero()[1] print test print real g = test - real non = g.nonzero()[0] print(1. - (len(non) / float(g.shape[0]))) * 100. f = N.function( [model.inbound_connections[0].input_tensors[0], model.targets[0]], model.metrics_tensors[0])
def clip_norm(g, clip, n): return N.switch(N.ge(n, clip), g * clip / n, g)
def get_error(self, target, output): diff = N.abs( (target - output) / N.clip(N.abs(target), N._epsilon, numpy.inf)) return 100. * N.mean(diff)
def _pooling_function(self, inputs, pool_size, strides, padding): output = N.pool2d(inputs, pool_size, strides, padding, pool_mode='max') return output
def get_error(self, target, output): return N.mean(N.binary_crossentropy(output, target))
def get_error(self, target, output): num = N.sum(N.square(target - output)) denom = N.sum(N.square(target)) return num / denom
def __init__(self, l1=0., l2=0.): self.l1 = N.cast(l1) self.l2 = N.cast(l2)
def get_error(self, target, output): return N.mean(N.maximum(1. - target * output, 0.))
def make_weights(self, shape, name): weights = numpy.random.RandomState(seed=self.seed).uniform(low=self.minval, high=self.maxval, size=shape) weights = weights.astype(N.floatx) return N.shared(weights, name=name)
def make_weights(self, shape,name): weights = _truncated_normal_vars(mean=self.mean, std=self.std, shape=shape, seed=self.seed) return N.shared(weights, name=name)
def make_weights(self, shape, name): weights = numpy.random.RandomState(seed=self.seed).normal(self.mean, self.std, size=shape) weights = weights.astype(N.floatx) return N.shared(weights, name=name)
def make_weights(self, shape, name): constant = self.value * numpy.ones(shape=shape, dtype=N.floatx) return N.shared(constant, name=name)
def make_weights(self, shape, name): return N.shared(numpy.ones(shape=shape, dtype=N.floatx), name=name)
def clip_grad(grad, clip=0): if (clip > 0): norm = N.sqrt(sum([N.sum(g**2) for g in grad])) return [clip_norm(g, clip, norm) for g in grad] return grad
def regularise(self, param): lOne = N.sum(N.abs(param)) * self.l1 lTwo = N.sum(N.square(param)) * self.l2 return lOne + lTwo
def get_weights(self): return [N.get_value(w) for w in self.weights]
def time_dist_dense(x, w, b, dropout=None, input_dim=None, output_dim=None, timesteps=None, training=False): """ Apply 'W.y + b' for every temporal slice y of x Inputs ------ @param x : tensor holding time series data @param w : weight matrix @param b : bias vector @param is_training: is the caller in training phase or not @param dropout : applies dropout to the operation @param input_dim: (optional) dimensionality of the input @param output_dim: (optional) dimensionality of the output @param timesteps: (optional) number of timesteps Returns ------- Output tensor """ if(not input_dim): input_dim = N.shape(x)[2] if(not timesteps): timesteps = N.shape(x)[1] if(not output_dim): output_dim = N.shape(w)[1] if(dropout is not None and 0. < dropout < 1.): ones = N.ones_like(N.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = N.dropout(ones, dropout) expanded_dropout_matrix = N.repeat(dropout_matrix, timesteps) if(training): x = x * expanded_dropout_matrix #collpse time dimension and batch dimension together x = N.reshape(x, (-1, input_dim)) x = N.dot(x, w) x += b #reshape to 3D if N.backend() == 'tensorflow': x = N.reshape(x, N.stack([-1, timesteps, output_dim])) x.set_shape([None, None, output_dim]) else: x = N.reshape(x, (-1, timesteps, output_dim)) return x
def get_error(self, target, output): return N.mean(N.categorical_crossentropy(output, target))
def get_cost(self): w_cost = self.w_regulariser(self.W) if self.w_regulariser else N.cast(0.) b_cost = self.b_regulariser(self.b) if self.b_regulariser else N.cast(0.) h_cost = self.h_regulariser(self.H) if self.h_regulariser else N.cast(0.) return w_cost + b_cost + h_cost
def get_error(self, target, output): return N.mean(N.square(target - output))
def get_weights(self): params = self.weights return [N.get_value(param) for param in params]
def get_error(self, target, output): return N.mean(N.abs(target - output))
def compile(self, optimiser, loss, metrics=[], **kwargs): """ Configures the model for training. Inputs ------ optimizer: str (name of optimizer) or optimizer object. See [optimizers](/optimizers). loss: str (name of objective function) or objective function. See [objectives](/objectives). If the model has multiple outputs, you can use a different loss on each output by passing a dictionary or a list of objectives. kwargs: when using the Theano backend, these arguments are passed into N.function. Ignored for Tensorflow backend. """ self.build() if (not isinstance(loss, list)): loss = [loss] self.optimiser = get_optimiser(optimiser) self.loss = loss if (len(loss) != len(self.outputs)): raise ValueError("loss should have one entry per output " "currently has {} entries".format(len(loss)) + "for {} outputs".format(len(self.outputs))) self.loss_functions = [get_objective(objective) for objective in loss] #prepare targets of model self.targets = [] for i in range(len(self.outputs)): shape = self.outputs[i]._nuro_shape name = self.output_layers[i].name self.targets.append( N.variable(ndim=len(shape), dtype=N.dtype(self.outputs[i]), name='h' + name + '_target')) #prepare metrics self.metrics = metrics self.metrics_names = ['loss'] self.metrics_tensors = [] #compute total loss total_loss = None for i in range(len(self.outputs)): y_true = self.targets[i] y_pred = self.outputs[i] loss_fn = self.loss_functions[i] if (total_loss is None): total_loss = loss_fn(y_true, y_pred) else: total_loss += loss_fn(y_true, y_pred) #add regularisation penalties total_loss += self.get_cost() # List of same size as output_names output_names = [n.name for n in self.outputs] nested_metrics = _collect_metrics(metrics, output_names) def append_metric(output_num, metric_name, metric_tensor): if (len(output_names) > 1): metric_name = self.outputs[output_num].name + "_" + metric_name self.metrics_names.append(metric_name) self.metrics_tensors.append(metric_tensor) for i in range(len(self.outputs)): y_true = self.targets[i] y_pred = self.outputs[i] output_metrics = nested_metrics[i] for metric in output_metrics: if (metric == 'accuracy' or metric == 'acc'): output_shape = self.outputs[i]._nuro_shape acc_fn = None if (output_shape[-1] == 1 or isinstance( self.loss_functions[i], BinaryXEntropy)): acc_fn = binary_accuracy elif (isinstance(self.loss_functions[i], CategoricalXEntropy)): acc_fn = categorical_accuracy append_metric(i, 'acc', acc_fn(y_true, y_pred)) #prepare gradient updates and state updates self.total_loss = total_loss # functions for train and test will # be created when required self._function_kwargs = kwargs self.train_function = None self.test_function = None
def categorical_accuracy(y_true, y_pred): return N.cast(N.equal(N.argmax(y_true, axis=-1), N.argmax(y_pred, axis=-1)), N.floatx)
def get_cost(self): return N.cast(0.)