def __init__(self):
# Layers
self.conv1 = l.Convolution("conv1",3,6,5,1)
self.conv2 = l.Convolution("conv2",6,16,5,1)
self.relu = l.ReLU("relu")
self.pool = l.Maxpooling("pooling",2,2)
self.dense1 = l.Dense("dense1",16*5*5,120)
self.dense2 = l.Dense("dense1",120,84)
self.dense3 = l.Dense("dense1",84,10)
def test_conv(self):
x = torch.ones(1, 4, 3, 3)
c = layers.Convolution((4, 3, 3), 4, k=2, rprop=.5, gadditional=2, radditional=2)
print(c(x))
def __init__(self, inputSize, outputSize):
super().__init__()
self.outputSize = outputSize
self.conv1 = layers.Convolution(5, 1)
self.Pool1 = layers.Pool(5, stride=2)
self.conv2 = layers.Convolution(10, 5)
self.Pool2 = layers.Pool(10, stride=2)
self.Flatten = layers.Flatten()
self.fc1 = layers.FullyConnected(7 * 7 * 10,
50,
activation=activate.Relu())
self.fc2 = layers.FullyConnected(50,
outputSize,
activation=activate.SoftMax())
self.inputLayer = self.conv1
self.outputLayer = self.fc2
self.conv1.addSon(self.Pool1)
self.Pool1.addSon(self.conv2)
self.conv2.addSon(self.Pool2)
self.Pool2.addSon(self.Flatten)
self.Flatten.addSon(self.fc1)
self.fc1.addSon(self.fc2)
def __init__(self, input_size, output_size, init_weight_std=0.01, filter_num=5, filter_size=3 ,pool_size = 2):
# input = [C, h, w]
size = input_size[1]
conv_out_size = (size - filter_size + 1)
pool_out_size = int((conv_out_size/2)**2*filter_num)
self.params = dict()
self.params["W1"] = init_weight_std * np.random.rand(filter_num,input_size[0], filter_size, filter_size)
self.params["b1"] = np.zeros(filter_num)
self.params["W2"] = init_weight_std * np.random.rand(pool_out_size, output_size)
self.params["b2"] = np.zeros(output_size)
self.layers = OrderedDict()
self.layers["Conv"] = L.Convolution(self.params["W1"], self.params["b1"])
self.layers["Activation1"] = L.Relu()
self.layers["Pooling"] = L.Pooling(pool_size,pool_size,stride=2)
self.layers["Affine1"] = L.Affine(self.params["W2"], self.params["b2"])
self.layers["Activation2"] = L.Relu()
self.output_layer = L.Softmax_with_loss()
self.y = None
def compose_layers(num_classes, layer_dims, shape_input):
embed_layer = layers.SelfInteractionSimple(layer_dims[0])
input_layer = layers.Input()
model_layers = []
for dim in layer_dims[1:]:
model_layers.append(layers.Convolution())
model_layers.append(layers.Concatenation())
model_layers.append(layers.SelfInteraction(dim))
model_layers.append(layers.Nonlinearity())
output_layer = layers.Output(num_classes)
x, rbf, rij = input_layer(shape_input)
input_tensor_list = {0: [embed_layer(x)]}
for layer in model_layers:
if isinstance(layer, layers.Convolution):
input_tensor_list = layer([input_tensor_list, rbf, rij])
else:
input_tensor_list = layer(input_tensor_list)
output = output_layer(input_tensor_list)
return output
train_x = ds_train.data.reshape([-1, 1, 28, 28]).numpy().astype(np.float) / 255
train_y = ds_train.targets.numpy()
train_x, valid_x = train_x[:55000], train_x[55000:]
train_y, valid_y = train_y[:55000], train_y[55000:]
test_x = ds_test.data.reshape([-1, 1, 28, 28]).numpy().astype(np.float) / 255
test_y = ds_test.targets.numpy()
train_mean = train_x.mean()
train_x, valid_x, test_x = (x - train_mean for x in (train_x, valid_x, test_x))
train_y, valid_y, test_y = (dense_to_one_hot(y, 10)
for y in (train_y, valid_y, test_y))
weight_decay = config['weight_decay']
net = []
regularizers = []
inputs = np.random.randn(config['batch_size'], 1, 28, 28)
net += [layers.Convolution(inputs, 16, 5, "conv1")]
regularizers += [
layers.L2Regularizer(net[-1].weights, weight_decay, 'conv1_l2reg')
]
net += [layers.MaxPooling(net[-1], "pool1")]
net += [layers.ReLU(net[-1], "relu1")]
net += [layers.Convolution(net[-1], 32, 5, "conv2")]
regularizers += [
layers.L2Regularizer(net[-1].weights, weight_decay, 'conv2_l2reg')
]
net += [layers.MaxPooling(net[-1], "pool2")]
net += [layers.ReLU(net[-1], "relu2")]
## 7x7
net += [layers.Flatten(net[-1], "flatten3")]
net += [layers.FC(net[-1], 512, "fc3")]
regularizers += [
grad_b_num = eval_numerical_gradient(func, b, grad_out)
grads = layer.backward_params(grad_out)
grad_w = grads[0][1]
grad_b = grads[1][1]
print("Check weights:")
print("Relative error = ", rel_error(grad_w_num, grad_w))
print("Error norm = ", np.linalg.norm(grad_w_num - grad_w))
print("Check biases:")
print("Relative error = ", rel_error(grad_b_num, grad_b))
print("Error norm = ", np.linalg.norm(grad_b_num - grad_b))
print("Convolution")
x = np.random.randn(4, 3, 5, 5)
grad_out = np.random.randn(4, 2, 5, 5)
conv = layers.Convolution(x, 2, 3, "conv1")
print("Check grad wrt input")
check_grad_inputs(conv, x, grad_out)
print("Check grad wrt params")
check_grad_params(conv, x, conv.weights, conv.bias, grad_out)
print("\nMaxPooling")
x = np.random.randn(5, 4, 8, 8)
grad_out = np.random.randn(5, 4, 4, 4)
pool = layers.MaxPooling(x, "pool", 2, 2)
print("Check grad wrt input")
check_grad_inputs(pool, x, grad_out)
print("\nReLU")
x = np.random.randn(4, 3, 5, 5)
grad_out = np.random.randn(4, 3, 5, 5)
np.set_printoptions(threshold=np.inf)
print((1, 2) + (3, ))
# c = np.array([[3,2,4,5,6],[1,2,3,4,5]])
# print(c)
# print(c.shape)
# a = np.zeros([3,3,4])
img = np.array([[[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23],
[30, 31, 32, 33]],
[[100, 101, 102, 103], [110, 111, 112, 113],
[120, 121, 122, 123], [130, 131, 132, 133]]])
# [[100,101,102,103],[110,111,112,113],[120,121,122,123],[130,131,132,133]]])
filter = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
c = L.Convolution(W=filter, b=np.zeros(filter.shape), stride=1)
print(c.forward(img))
# print(b)
#
# filter_h, filter_w = filter.shape
# stride = 1
#
# N, H, W = b.shape
# print(N)
# out_h = (H - filter_h) // stride + 1
# out_w = (W - filter_w) // stride + 1
#
#
# col = np.zeros((N, filter_h, filter_w, out_h, out_w))
# # col[0,0,:,:] = b[0:5,0:5]
n_examples = len(images)
cost_values = []
network_name = "AlexNet"
graph = ComputationalGraph(network_name,
loss_function="cross-entropy",
lr=1e-4,
reg=1e-5)
graph.add_layer(
layers.Convolution("conv1",
kernel_size=11,
kernel_channels=3,
n_kernels=96,
stride=4,
same_padding=False,
logging=False))
graph.add_layer(layers.Activation(activation="relu", logging=False))
graph.add_layer(
layers.MaxPooling(window_size=3,
window_channels=96,
stride=2,
logging=False))
graph.add_layer(
layers.Convolution("conv2",
kernel_size=5,
kernel_channels=96,
n_kernels=256,
valid_x = dataset.validation.images
valid_x = valid_x.reshape([-1, 1, 28, 28])
valid_y = dataset.validation.labels
test_x = dataset.test.images
test_x = test_x.reshape([-1, 1, 28, 28])
test_y = dataset.test.labels
train_mean = train_x.mean()
train_x -= train_mean
valid_x -= train_mean
test_x -= train_mean
net = []
inputs = np.random.randn(
config['batch_size'], 1, 28, 28
) #cemu normalna razdioba, neki placeholder za stvarne podatke? samo zbog shapea?
net += [layers.Convolution(inputs, 16, 5,
"conv1")] #num filters = 16, kernel size= 5
net += [layers.MaxPooling(net[-1], "pool1")] #ulazni parametar je ulaz u layer
net += [layers.ReLU(net[-1], "relu1")]
net += [layers.Convolution(net[-1], 32, 5, "conv2")]
net += [layers.MaxPooling(net[-1], "pool2")]
net += [layers.ReLU(net[-1], "relu2")]
# out = 7x7
net += [layers.Flatten(net[-1], "flatten3")]
net += [layers.FC(net[-1], 512, "fc3")]
net += [layers.ReLU(net[-1], "relu3")]
net += [layers.FC(net[-1], 10, "logits")]
loss = layers.SoftmaxCrossEntropyWithLogits()
nn.train(train_x, train_y, valid_x, valid_y, net, loss, config)
nn.evaluate("Test", test_x, test_y, net, loss, config)
#X = X[np.newaxis, :, :, :]
images.append(X)
return np.stack(images, axis=0)
X = load_images(["billie.png"], IMG_SIZE=50)
print(X.shape)
T = np.array([1, 0, 0, 0, 0])
T = T.T
######################################################################################################################
conv = layers.Convolution(kernel_size=3,
kernel_channels=3,
n_kernels=10,
stride=1,
same_padding=True)
X = conv.forward(X)
print("[+] CONVOLVED_shape:", X.shape)
print()
activation = layers.Activation(activation="relu")
X = activation.forward(X)
print("[+] ACTIVATION_shape:", X.shape)
dActivation = activation.backward(np.ones_like(X))
print("dActivation_SHAPE:", dActivation.shape)
print()
maxpool = layers.MaxPooling(window_size=2, window_channels=10, stride=2)
X = maxpool.forward(X)
def __init__(self):
super(CapsNet, self).__init__()
self.conv_layer = layers.Convolution()
self.primary_caps = layers.PrimaryCaps()
self.digit_caps = layers.DigitCaps()
self.decoder = layers.Decoder()
