def knode( self, category='person' ): """ insert a Nengo node for Keras interface """ if category in self.nodes: raise ValueError( "node's label {} already in use".format( category ) ) size_in = numpy.prod( shapes[ category ] ) size_out = shapes[ category ][ 0 ] label = category node = Kinter( category ) self.nodes[ label ] = nengo_dl.TensorNode( node, size_in=size_in, size_out=size_out, label=label )
def node( self, node, label, ntype='tf' ): """ insert a Nengo node """ if label in self.nodes: raise ValueError( "node's label {} already in use".format( label ) ) if ntype == 'tf': size_out = n_imgs * n_class self.nodes[ label ] = nengo_dl.TensorNode( node, size_in=i_size, size_out=size_out, label=label ) if ntype == 'nengo': self.nodes[ label ] = nengo.Node( node, size_in=i_size, size_out=n_class, label=label )
def setup_nn(seed=1): """ build main nengo network """ nn = nengo.Network(seed=seed) with nn: v = nengo_dl.TensorNode(Vision(), size_in=i_size, size_out=n_class, label="cnn") o = nengo.Probe(v, label="cnn_result") return nn
def r_nn(image): """ recall the nengo network on the given image """ img = flat_cifar.img_numpy(image) with nengo.Network() as nn: i = nengo.Node(output=img.flatten()) v = nengo_dl.TensorNode(Vision(), size_in=i_size, size_out=n_class, label="cnn") nengo.Connection(i, v, synapse=None, label="img_to_cnn") o = nengo.Probe(v, label="cnn_result") with nengo_dl.Simulator(nn) as sim: sim.step() return sim.data[o][0]
def mnist(use_tensor_layer=True): """ A network designed to stress-test tensor layers (based on mnist net). Parameters ---------- use_tensor_layer : bool If True, use individual tensor_layers to build the network, as opposed to a single TensorNode containing all layers. Returns ------- net : `nengo.Network` benchmark network """ with nengo.Network() as net: # create node to feed in images net.inp = nengo.Node(np.ones(28 * 28)) if use_tensor_layer: nengo_nl = nengo.RectifiedLinear() ensemble_params = dict(max_rates=nengo.dists.Choice([100]), intercepts=nengo.dists.Choice([0])) amplitude = 1 synapse = None x = nengo_dl.tensor_layer(net.inp, tf.layers.conv2d, shape_in=(28, 28, 1), filters=32, kernel_size=3) x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params) x = nengo_dl.tensor_layer(x, tf.layers.conv2d, shape_in=(26, 26, 32), transform=amplitude, filters=32, kernel_size=3) x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params) x = nengo_dl.tensor_layer(x, tf.layers.average_pooling2d, shape_in=(24, 24, 32), synapse=synapse, transform=amplitude, pool_size=2, strides=2) x = nengo_dl.tensor_layer(x, tf.layers.dense, units=128) x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params) x = nengo_dl.tensor_layer(x, tf.layers.dropout, rate=0.4, transform=amplitude) x = nengo_dl.tensor_layer(x, tf.layers.dense, units=10) else: nl = tf.nn.relu # def softlif_layer(x, sigma=1, tau_ref=0.002, tau_rc=0.02, # amplitude=1): # # x -= 1 # z = tf.nn.softplus(x / sigma) * sigma # z += 1e-10 # rates = amplitude / (tau_ref + tau_rc * tf.log1p(1 / z)) # return rates @nengo_dl.reshaped((28, 28, 1)) def mnist_node(_, x): # pragma: no cover x = tf.layers.conv2d(x, filters=32, kernel_size=3, activation=nl) x = tf.layers.conv2d(x, filters=32, kernel_size=3, activation=nl) x = tf.layers.average_pooling2d(x, pool_size=2, strides=2) x = tf.contrib.layers.flatten(x) x = tf.layers.dense(x, 128, activation=nl) x = tf.layers.dropout(x, rate=0.4) x = tf.layers.dense(x, 10) return x node = nengo_dl.TensorNode(mnist_node, size_in=28 * 28, size_out=10) x = node nengo.Connection(net.inp, node, synapse=None) net.p = nengo.Probe(x) return net
def three(): K.clear_session() data = [] """ labels = [['black', 'jeans']]*344 + [['blue', 'dress']]*386 + [['blue', 'jeans']]*356 + [['blue', 'shirt']]*369 + \ [['blue', 'sweater']]*99 + [['gray', 'shorts']]*96 + [['red', 'dress']]*380 + [['red', 'shirt']]*332 """ EPOCHS = 25 INIT_LR = 1e-3 BS = 32 IMAGE_DIMS = (96, 96, 3) checkpoints_dir = '.\\checkpoints' # load the image, pre-process it, and store it in the data list import glob image_types = ('*.jpg', '*.jpeg', '*.png') files = [] labels = [] folders = glob.glob( "D:\\Users\\bob\\PycharmProjects\\test_recommendation\\nengo_classification\\dataset\\*\\" ) for image_type in image_types: files.extend( glob.glob( "D:\\Users\\bob\\PycharmProjects\\test_recommendation\\nengo_classification\\dataset\\*\\" + image_type)) print(len(files)) for f in files: """ image = cv2.imread(f) image = cv2.resize(image, (IMAGE_DIMS[1], IMAGE_DIMS[0])) image = img_to_array(image) data.append(image) """ label = f.split("\\")[-2].split("_") labels.append(label) # scale the raw pixel intensities to the range [0, 1] data = np.load("data.npy") labels = np.array(labels) # print("[INFO] data matrix: {} images ({:.2f}MB)".format(len(imagePaths), data.nbytes / (1024 * 1000.0))) # binarize the labels using scikit-learn's special multi-label # binarizer implementation # print("[INFO] class labels:") mlb = MultiLabelBinarizer() labels = mlb.fit_transform(labels) #print(labels) """ # loop over each of the possible class labels and show them for (i, label) in enumerate(mlb.classes_): print("{}. {}".format(i + 1, label)) print(data.shape) print(labels.shape) # partition the data into training and testing splits using 80% of # the data for training and the remaining 20% for testing (trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=0.2, random_state=42) # construct the image generator for data augmentation aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1, height_shift_range=0.1, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode="nearest") # initialize the model using a sigmoid activation as the final layer # in the network so we can perform multi-label classification print("[INFO] compiling model...") model = SmallerVGGNet.build( width=IMAGE_DIMS[1], height=IMAGE_DIMS[0], depth=IMAGE_DIMS[2], classes=len(mlb.classes_), finalAct="sigmoid") # initialize the optimizer (SGD is sufficient) opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS) # compile the model using binary cross-entropy rather than # categorical cross-entropy -- this may seem counterintuitive for # multi-label classification, but keep in mind that the goal here # is to treat each output label as an independent Bernoulli # distribution model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) print("[INFO] training network...") H = model.fit_generator( aug.flow(trainX, trainY, batch_size=BS), validation_data=(testX, testY), steps_per_epoch=len(trainX) // BS, epochs=EPOCHS, verbose=1) # save the model to disk print("[INFO] serializing network...") model.save("fashion_model.h5") model.save_weights("fashion_model_weights.h5") plt.style.use("ggplot") plt.figure() N = EPOCHS plt.plot(np.arange(0, N), H.history["loss"], label="train_loss") plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss") plt.plot(np.arange(0, N), H.history["acc"], label="train_acc") plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc") plt.title("Training Loss and Accuracy") plt.xlabel("Epoch #") plt.ylabel("Loss/Accuracy") plt.legend(loc="upper left") plt.savefig("plot.png") """ class KerasNode: def __init__(self, keras_model, mlb): self.model = keras_model self.mlb = mlb def pre_build(self, *args): self.model = clone_model(self.model) def __call__(self, t, x): # pre-process the image for classification img = tf.reshape(x, (-1, ) + IMAGE_DIMS) #print(img.shape) """ img = cv2.resize(img, (96, 96)) img = img.astype("float") / 255.0 img = img_to_array(img) img = np.expand_dims(img, axis=0) """ return self.model.call(img) #eturn self.model.call(tf.convert_to_tensor(img, dtype=tf.float32)) def post_build(self, sess, rng): with sess.as_default(): self.model.load_weights("fashion_model_weights.h5") self.mlb = pickle.loads(open("mlb.pickle", "rb").read()) #pass net_input_shape = np.prod((96, 96, 3)) # because input will be a vector with nengo.Network() as net: # create a normal input node to feed in our test image. # the `np.ones` array is a placeholder, these # values will be replaced with the Fashion MNIST images # when we run the Simulator. input_node = nengo.Node(output=np.ones((net_input_shape, ))) # create a TensorNode containing the KerasNode we defined # above, passing it the Keras model we created. # we also need to specify size_in (the dimensionality of # our input vectors, the flattened images) and size_out (the number # of classification classes output by the keras network) model = load_model("fashion_model.h5") mlb = pickle.loads(open("mlb.pickle", "rb").read()) keras_node = nengo_dl.TensorNode(KerasNode(model, mlb), size_in=net_input_shape, size_out=len(mlb.classes_)) # connect up our input to our keras node nengo.Connection(input_node, keras_node, synapse=None) # add a probes to collect output of keras node keras_p = nengo.Probe(keras_node) input_p = nengo.Probe(input_node) minibatch_size = 20 np.random.seed(3) test_inds = np.random.randint(low=0, high=data.shape[0], size=(minibatch_size, )) test_inputs = data[test_inds] # flatten images so we can pass them as vectors to the input node test_inputs = test_inputs.reshape((-1, net_input_shape)) # unlike in Keras, NengoDl simulations always run over time. # so we need to add the time dimension to our data (even though # in this case we'll just run for a single timestep). test_inputs = test_inputs[:, None, :] with nengo_dl.Simulator(net, minibatch_size=len(test_inputs)) as sim: sim.step(data={input_node: test_inputs}) tensornode_output = sim.data[keras_p] for i in range(len(test_inputs)): plt.figure() b, g, r = cv2.split(data[test_inds[i]]) rgb_img = cv2.merge([r, g, b]) plt.imshow(rgb_img) print("[INFO] classifying ...") proba = tensornode_output[i][0] print(proba) idxs = np.argsort(proba)[::-1] print(idxs) print(np.argmax(tensornode_output[i, 0])) plt.axis("off") plt.title("%s, %s" % (mlb.classes_[idxs[0]], mlb.classes_[idxs[1]])) plt.show()
def __init__(self, units, order, theta, input_d, **kwargs): super().__init__(**kwargs) # compute the A and B matrices according to the LMU's mathematical # derivation (see the paper for details) Q = np.arange(order, dtype=np.float64) R = (2 * Q + 1)[:, None] / theta j, i = np.meshgrid(Q, Q) A = np.where(i < j, -1, (-1.0) ** (i - j + 1)) * R B = (-1.0) ** Q[:, None] * R C = np.ones((1, order)) D = np.zeros((1,)) A, B, _, _, _ = cont2discrete((A, B, C, D), dt=1.0, method="zoh") with self: nengo_dl.configure_settings(trainable=None) # create objects corresponding to the x/u/m/h variables in LMU self.x = nengo.Node(size_in=input_d) self.u = nengo.Node(size_in=1) self.m = nengo.Node(size_in=order) self.h = nengo_dl.TensorNode( tf.nn.tanh, shape_in=(units,), pass_time=False ) # compute u_t # note that setting synapse=0 (versus synapse=None) adds a # one-timestep delay, so we can think of any connections with # synapse=0 as representing value_{t-1} nengo.Connection( self.x, self.u, transform=np.ones((1, input_d)), synapse=None ) nengo.Connection( self.h, self.u, transform=np.zeros((1, units)), synapse=0 ) nengo.Connection( self.m, self.u, transform=np.zeros((1, order)), synapse=0 ) # compute m_t # in this implementation we'll make A and B non-trainable, but they # could also be optimized in the same way as the other parameters conn = nengo.Connection(self.m, self.m, transform=A, synapse=0) self.config[conn].trainable = False conn = nengo.Connection(self.u, self.m, transform=B, synapse=None) self.config[conn].trainable = False # compute h_t nengo.Connection( self.x, self.h, transform=np.zeros((units, input_d)), synapse=None, ) nengo.Connection( self.h, self.h, transform=np.zeros((units, units)), synapse=0 ) nengo.Connection( self.m, self.h, transform=nengo_dl.dists.Glorot(distribution="normal"), synapse=None, )
def build_network(neuron_type, drop_p, l2_weight, n_units=1024, num_layers=4, output_size=1): with nengo.Network() as net: use_dropout = False if drop_p: use_dropout = True #net.config[nengo.Connection].synapse = None #nengo_dl.configure_settings(trainable=False) # input node inp = nengo.Node([0]) shape_in = 1 x = inp # the regularizer is a function, so why not reuse it reg = tf.contrib.layers.l2_regularizer(l2_weight) class DenseLayer(object): i = 0 def pre_build(self, shape_in, shape_out): self.W = tf.get_variable("weights" + str(DenseLayer.i), shape=(shape_in[1], shape_out[1]), regularizer=reg) self.B = tf.get_variable("biases" + str(DenseLayer.i), shape=(1, shape_out[1]), regularizer=reg) DenseLayer.i += 1 def __call__(self, t, x): return x @ self.W + self.B for n in range(num_layers): # add a fully connected layer a = nengo_dl.TensorNode(DenseLayer(), size_in=shape_in, size_out=n_units, label='dense{}'.format(n)) nengo.Connection(x, a, synapse=None) shape_in = n_units x = a # apply an activation function x = nengo_dl.tensor_layer(x, neuron_type, **ens_params) # add a dropout layer x = nengo_dl.tensor_layer(x, tf.layers.dropout, rate=drop_p, training=use_dropout) # add an output layer a = nengo_dl.TensorNode(DenseLayer(), size_in=shape_in, size_out=output_size) nengo.Connection(x, a, synapse=None) return net, inp, a
# snippet 5 (section 3.2) import tensorflow as tf inputs = np.random.randn(50, 1000, 1) targets = inputs**2 with nengo_dl.Simulator(net, minibatch_size=10) as sim: sim.train(inputs={a: inputs}, targets={p: targets}, optimizer=tf.train.AdamOptimizer(), n_epochs=2, objective="mse") # snippet 6 (section 3.3) with net: def tensor_func(t, x): return tf.layers.dense(x, 100, activation=tf.nn.relu) t = nengo_dl.TensorNode(tensor_func, size_in=1) nengo.Connection(a, t) nengo.Connection(t, b.neurons) # snippet 7 (section 3.3) with net: t = nengo_dl.tensor_layer(a, tf.layers.dense, units=100, activation=tf.nn.relu) nengo.Connection(t, b.neurons)