def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
width, height, channels = input_shape
self.conv1 = ConvolutionalLayer(in_channels=3,
out_channels=3,
filter_size=conv1_channels)
self.relu1 = ReLULayer()
self.maxpool1 = MaxPoolingLayer(4, 4)
self.conv2 = ConvolutionalLayer(in_channels=3,
out_channels=3,
filter_size=conv2_channels)
self.relu2 = ReLULayer()
self.maxpool2 = MaxPoolingLayer(4, 4)
self.flatten = Flattener()
self.f_connected = FullyConnectedLayer(3, n_output_classes)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
width, height, channels = input_shape
filter_size = 3
padding = 1
pool_size = 4
pool_stride = 4
self.Conv1 = ConvolutionalLayer(channels, conv1_channels, filter_size,
padding)
self.ReLU1 = ReLULayer()
self.MaxPool1 = MaxPoolingLayer(pool_size, pool_stride)
self.Conv2 = ConvolutionalLayer(conv1_channels, conv2_channels,
filter_size, padding)
self.ReLU2 = ReLULayer()
self.MaxPool2 = MaxPoolingLayer(pool_size, pool_stride)
left_width = width // pool_stride // pool_stride
left_height = height // pool_stride // pool_stride
self.Flat = Flattener()
self.FullyConnected = FullyConnectedLayer(
left_width * left_height * conv2_channels, n_output_classes)
def __init__(self, num_input, num_cells=50, num_output=1, lr=0.01, rho=0.95):
X = T.matrix('x')
Y = T.matrix('y')
eta = T.scalar('eta')
alpha = T.scalar('alpha')
self.num_input = num_input
self.num_output = num_output
self.num_cells = num_cells
self.eta = eta
inputs = InputLayer(X, name="inputs")
lstm = LSTMLayer(num_input, num_cells, input_layer=inputs, name="lstm")
fc = FullyConnectedLayer(num_cells, num_output, input_layer=lstm)
Y_hat = T.mean(fc.output(), axis=2)
layer = inputs, lstm, fc
self.params = get_params(layer)
self.caches = make_caches(self.params)
self.layers = layer
mean_cost = T.mean((Y - Y_hat)**2)
last_cost = T.mean((Y[-1] - Y_hat[-1])**2)
self.cost = alpha*mean_cost + (1-alpha)*last_cost
""""
self.updates = momentum(self.cost, self.params, self.caches, self.eta, clip_at=3.0)
"""
self.updates,_,_,_,_ = create_optimization_updates(self.cost, self.params, method="adadelta", lr= lr, rho=rho)
self.train = theano.function([X, Y, alpha], [self.cost, last_cost] ,\
updates=self.updates, allow_input_downcast=True)
self.costfn = theano.function([X, Y, alpha], [self.cost, last_cost],\
allow_input_downcast=True)
self.predict = theano.function([X], [Y_hat], allow_input_downcast=True)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
self.input_shape = input_shape
self.n_output_classes = n_output_classes
self.layer1 = ConvolutionalLayer(3, conv1_channels, 3,
1) #32x32x3xconv1_channels
self.layer2 = ReLULayer()
self.layer3 = MaxPoolingLayer(4, 4) #8x8x3xconv1_channels
self.layer4 = ConvolutionalLayer(
conv1_channels, conv2_channels, 3,
1) #8x8x3x conv1_channels x conv2_channels
self.layer5 = ReLULayer()
self.layer6 = MaxPoolingLayer(
4, 4) #2x2x3 conv1_channels x conv2_channels
self.layer7 = Flattener()
self.layer8 = FullyConnectedLayer(conv1_channels * conv2_channels * 2,
n_output_classes)
def __init__(self, input_shape, n_output_classes, conv1_channels, conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
self.height = input_shape[0]
self.width = input_shape[1]
self.input_channels = input_shape[2]
self.n_output_classes = n_output_classes
self.conv1_channels = conv1_channels
self.conv2_channels = conv2_channels
self.conv1_layer = ConvolutionalLayer(self.input_channels, self.conv1_channels, 3, 1)
self.relu1 = ReLULayer()
self.maxpool1 = MaxPoolingLayer(4, 4)
self.conv2_layer = ConvolutionalLayer(self.conv1_channels, self.conv2_channels, 3, 1)
self.relu2 = ReLULayer()
self.maxpool2 = MaxPoolingLayer(4, 4)
self.flattener = Flattener()
self.fc_layer = FullyConnectedLayer(2*2*self.conv2_channels, self.n_output_classes)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
width, height, n_channels = input_shape
self.conv1 = ConvolutionalLayer(n_channels, conv1_channels, 3, 1)
self.relu1 = ReLULayer()
self.maxpool1 = MaxPoolingLayer(4, 4)
self.conv2 = ConvolutionalLayer(conv1_channels, conv2_channels, 3, 1)
self.relu2 = ReLULayer()
self.maxpool2 = MaxPoolingLayer(4, 4)
self.flatten = Flattener()
self.fc = FullyConnectedLayer(
(height // 4 // 4) * (width // 4 // 4) * conv2_channels,
n_output_classes)
self.conv1_params = self.conv1.params()
self.conv2_params = self.conv2.params()
self.fc_params = self.fc.params()
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
input_width, input_height, input_channels = input_shape
self.conv1 = ConvolutionalLayer(input_channels,
conv1_channels,
filter_size=3,
padding=1)
self.relu1 = ReLULayer()
self.maxpool1 = MaxPoolingLayer(pool_size=4, stride=4)
self.conv2 = ConvolutionalLayer(conv1_channels,
conv2_channels,
filter_size=3,
padding=1)
self.relu2 = ReLULayer()
self.maxpool2 = MaxPoolingLayer(pool_size=4, stride=4)
self.flattener = Flattener()
self.fc = FullyConnectedLayer(
input_width * input_height * conv2_channels // (4**4),
n_output_classes)
def __init__(self, input_shape, n_output_classes, conv1_channels, conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO_ Create necessary layers
# raise Exception("Not implemented!")
weight, height, cannels = input_shape
filter_size = 3
pool_size = 4
padding = 1
stride = pool_size
self.conv1 = ConvolutionalLayer(cannels, conv1_channels, filter_size, padding)
self.relu1 = ReLULayer()
self.maxpool1 = MaxPoolingLayer(pool_size, stride)
self.conv2 = ConvolutionalLayer(conv1_channels, conv2_channels, filter_size, padding)
self.relu2 = ReLULayer()
self.maxpool2 = MaxPoolingLayer(pool_size, stride)
self.flatten = Flattener()
n_fc_input = int(height / pool_size / pool_size * weight / pool_size / pool_size * conv2_channels)
self.fc = FullyConnectedLayer(n_fc_input, n_output_classes)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
#raise Exception("Not implemented!")
image_width, image_height, n_channels = input_shape
self.conv1 = ConvolutionalLayer(n_channels, conv1_channels, 3, 1)
self.relu1 = ReLULayer()
self.maxp1 = MaxPoolingLayer(4, 4)
self.conv2 = ConvolutionalLayer(conv1_channels, conv2_channels, 3, 1)
self.relu2 = ReLULayer()
self.maxp2 = MaxPoolingLayer(4, 4)
self.flatn = Flattener()
fc_input = int(image_width * image_height * conv2_channels / pow(4, 4))
self.fc = FullyConnectedLayer(fc_input, n_output_classes)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
# TODO Create necessary layers
self.fully_layers = []
self.relu_layers = []
inp = n_input
out = n_output
for l in range(hidden_layer_size):
#print ("inp = %, out = % ", inp, out)
self.fully_layers.append(FullyConnectedLayer(inp, out))
#inp, out = out, inp
inp = 10
self.relu_layers.append(ReLULayer())
self.fully_layers.append(FullyConnectedLayer(inp, n_output))
#raise Exception("Not implemented!")
"""
self.reg = reg
self.input_fc = FullyConnectedLayer(n_input, hidden_layer_size)
self.input_re = ReLULayer()
self.hidden_fc = FullyConnectedLayer(hidden_layer_size, n_output)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
filter_size = 3
pool_size = 4
self.conv1 = ConvolutionalLayer(input_shape[2],
conv1_channels,
filter_size,
padding=1)
self.relu1 = ReLULayer()
self.max_pool1 = MaxPoolingLayer(pool_size, stride=pool_size)
self.conv2 = ConvolutionalLayer(conv1_channels,
conv2_channels,
filter_size,
padding=1)
self.relu2 = ReLULayer()
self.max_pool2 = MaxPoolingLayer(pool_size, stride=pool_size)
self.flatten = Flattener()
self.fc = FullyConnectedLayer(n_input=4 * conv2_channels,
n_output=n_output_classes)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
self.layers = [
FullyConnectedLayer(n_input, hidden_layer_size),
ReLULayer(),
FullyConnectedLayer(hidden_layer_size, n_output)
]
self.reg = reg
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization ngth
"""
self.result = {}
self.reg = reg
self.n_input = n_input
self.n_output = n_output
self.hidden_layer_size = hidden_layer_size
# # TODO Create necessary layers
self.first_layer = FullyConnectedLayer(self.n_input,
self.hidden_layer_size)
self.first_relu = ReLULayer()
self.second_layer = FullyConnectedLayer(self.hidden_layer_size,
self.n_output)
self.second_relu = ReLULayer()
first_layer_param = self.first_layer.params()
self.result['first_l_param_W'] = first_layer_param['W']
self.result['first_l_param_B'] = first_layer_param['B']
second_layer_param = self.second_layer.params()
self.result['second_l_param_W'] = second_layer_param['W']
self.result['second_l_param_B'] = second_layer_param['B']
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
self.out_classes = n_output_classes
image_width, image_height, in_channels = input_shape
self.Conv1 = ConvolutionalLayer(in_channels, conv1_channels, 3, 1)
self.ReLU1 = ReLULayer()
self.MaxPool1 = MaxPoolingLayer(4, 4)
self.Conv2 = ConvolutionalLayer(conv1_channels, conv2_channels, 3, 1)
self.ReLU2 = ReLULayer()
self.MaxPool2 = MaxPoolingLayer(4, 4)
self.Flatten = Flattener()
self.FC = FullyConnectedLayer(4 * conv2_channels, n_output_classes)
def ensure_layers(self):
if self.layers is None:
self.layers = [
("Input Layer",
FullyConnectedLayer(self.n_input, self.hidden_layer_size)),
("ReLU Layer", ReLULayer()),
("Hidden Layer",
FullyConnectedLayer(self.hidden_layer_size, self.n_output)),
]
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
:param n_input: int - dimension of the model input
:param n_output: int - number of classes to predict
:param hidden_layer_size: int - number of neurons in the hidden layer
:param reg: float - L2 regularization strength
"""
self.reg = reg
self.layer_one = FullyConnectedLayer(n_input, hidden_layer_size)
self.layer_ReLU = ReLULayer()
self.layer_two = FullyConnectedLayer(hidden_layer_size, n_output)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
self.layer_1 = FullyConnectedLayer(n_input, hidden_layer_size)
self.non_linier = ReLULayer()
self.layer_2 = FullyConnectedLayer(hidden_layer_size, n_output)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
# TODO Create necessary layers
self.hidden_layer1 = FullyConnectedLayer(n_input, hidden_layer_size)
self.hidden_layer2 = FullyConnectedLayer(hidden_layer_size, n_output)
self.relu_layer1 = ReLULayer()
self.relu_layer2 = ReLULayer()
def __init__(self, hidden_layer_size, i, o, reg):
"""
Initializes the neural network
Arguments:
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
self.layers = []
for num_layer in range(1):
self.layers.append(FullyConnectedLayer(i,hidden_layer_size))
self.layers.append(ReLULayer())
self.layers.append(FullyConnectedLayer(hidden_layer_size,o))
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
# TODO Create necessary layers
self.first = FullyConnectedLayer(n_input, hidden_layer_size)
self.relu = ReLULayer()
self.second = FullyConnectedLayer(hidden_layer_size, n_output)
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
self.layers = [
ConvolutionalLayer(in_channels=input_shape[2],
out_channels=input_shape[2],
filter_size=conv1_channels,
padding=2),
ReLULayer(),
MaxPoolingLayer(pool_size=4, stride=2), #2
ConvolutionalLayer(in_channels=input_shape[2],
out_channels=input_shape[2],
filter_size=conv2_channels,
padding=2),
ReLULayer(),
MaxPoolingLayer(pool_size=4, stride=2), #2
Flattener(),
FullyConnectedLayer(n_input=192, n_output=n_output_classes)
] #192
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
self.layers = [
ConvolutionalLayer(input_shape[2], conv1_channels, 3, 0),
ReLULayer(),
MaxPoolingLayer(4, 4),
ConvolutionalLayer(conv1_channels, conv2_channels, 3, 0),
ReLULayer(),
MaxPoolingLayer(4, 4),
Flattener(),
FullyConnectedLayer(
int(input_shape[0] * input_shape[1] * conv2_channels / 256),
n_output_classes)
]
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
# TODO Create necessary layers
# raise Exception("Not implemented!")
self.out_classes = n_output_classes
image_width, image_height, in_channels = input_shape
self.layers = [
ConvolutionalLayer(in_channels, conv1_channels, 3, 1),
ReLULayer(),
MaxPoolingLayer(4, 4),
ConvolutionalLayer(conv1_channels, conv2_channels, 3, 1),
ReLULayer(),
MaxPoolingLayer(4, 4),
Flattener(),
FullyConnectedLayer(4 * conv2_channels, n_output_classes)
]
def __init__(self, input_shape, n_output_classes, conv1_channels,
conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
self.model = [
ConvolutionalLayer(in_channels=input_shape[2],
out_channels=conv1_channels,
filter_size=3,
padding=1),
ReLULayer(),
MaxPoolingLayer(2, 2),
ConvolutionalLayer(in_channels=conv1_channels,
out_channels=conv2_channels,
filter_size=3,
padding=1),
ReLULayer(),
MaxPoolingLayer(2, 2),
Flattener(),
FullyConnectedLayer(n_input=int(input_shape[0] / 4)**2 *
conv2_channels,
n_output=n_output_classes)
]
def __init__(self, input_shape, n_output_classes, conv1_channels, conv2_channels):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
width, height, n_channels = input_shape
conv = 3
pad = 1
stride = 4
pool = 4
hidden_layer_size = (width // stride // stride) * (height // stride // stride) * conv2_channels
self.layers = [
ConvolutionalLayer(n_channels, conv1_channels, conv, pad),
ReLULayer(),
MaxPoolingLayer(pool, stride),
ConvolutionalLayer(conv1_channels, conv2_channels, conv, pad),
ReLULayer(),
MaxPoolingLayer(pool, stride),
Flattener(),
FullyConnectedLayer(hidden_layer_size, n_output_classes)
]
def __init__(self, n_input, n_output, conv1_size, conv2_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
conv1_size, int - number of filters in the 1st conv layer
conv2_size, int - number of filters in the 2nd conv layer
reg, float - L2 regularization strength
"""
self.reg = reg
height, width, input_channels = n_input
self.L = [
ConvolutionalLayer(in_channels=input_channels,
out_channels=conv1_size,
filter_size=3,
padding=1),
ReLULayer(),
MaxPoolingLayer(4, 4),
ConvolutionalLayer(in_channels=conv1_size,
out_channels=conv2_size,
filter_size=3,
padding=1),
ReLULayer(),
MaxPoolingLayer(4, 4),
Flattener(),
FullyConnectedLayer(8, n_output)
]
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
hidden_layer_size, int - number of neurons in the hidden layer
n_input, int - dimension of the model input
reg, float - L2 regularization strength
"""
self.reg = reg
self.input_layer = FullyConnectedLayer(n_input, hidden_layer_size)
self.relu = ReLULayer()
self.output_layer = FullyConnectedLayer(hidden_layer_size, n_output)
self.W_in = None
self.W_out = None
self.B_in = None
self.B_out = None
def __init__(self,
input_shape,
n_output_classes,
conv1_channels,
conv2_channels,
filter_size=3):
"""
Initializes the neural network
Arguments:
input_shape, tuple of 3 ints - image_width, image_height, n_channels
Will be equal to (32, 32, 3)
n_output_classes, int - number of classes to predict
conv1_channels, int - number of filters in the 1st conv layer
conv2_channels, int - number of filters in the 2nd conv layer
"""
self.input_shape = input_shape
self.n_output_classes = n_output_classes
self.conv1_channels = conv1_channels
self.conv2_channels = conv2_channels
self.filter_size = filter_size
self.padding = 1
c1 = int(
(input_shape[0] - self.filter_size + 2 * self.padding) / 1) + 1
mp1 = int((c1 - 4) / 4) + 1
c2 = int((mp1 - self.filter_size + 2 * self.padding) / 1) + 1
self.size_after_2maxpool = int((c2 - 4) / 4) + 1
self.RL1 = ReLULayer()
self.RL2 = ReLULayer()
self.MaxPool1 = MaxPoolingLayer(pool_size=4, stride=4)
self.MaxPool2 = MaxPoolingLayer(pool_size=4, stride=4)
self.Flatten = Flattener()
self.Conv1 = ConvolutionalLayer(in_channels=self.input_shape[-1],
out_channels=conv1_channels,
filter_size=self.filter_size,
padding=self.padding)
self.Conv2 = ConvolutionalLayer(in_channels=conv1_channels,
out_channels=conv2_channels,
filter_size=self.filter_size,
padding=self.padding)
self.FC = FullyConnectedLayer(n_input=conv2_channels *
self.size_after_2maxpool**2,
n_output=self.n_output_classes)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
# TODO_ Create necessary layers
# raise Exception("Not implemented!")
self.layer1 = FullyConnectedLayer(n_input, hidden_layer_size)
self.relu_layer = ReLULayer()
self.layer2 = FullyConnectedLayer(hidden_layer_size, n_output)
def __init__(self, n_input, n_output, hidden_layer_size, reg):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.fcl1 = FullyConnectedLayer(n_input, hidden_layer_size)
self.fcl2 = FullyConnectedLayer(hidden_layer_size, n_output)
self.relu = ReLULayer()
self.reg = reg
self.w1 = self.fcl1.params()['W']
self.w2 = self.fcl2.params()['W']
self.b1 = self.fcl1.params()['B']
self.b2 = self.fcl1.params()['B']
def __init__(self, n_input, n_output, hidden_layer_size, reg=0):
"""
Initializes the neural network
Arguments:
n_input, int - dimension of the model input
n_output, int - number of classes to predict
hidden_layer_size, int - number of neurons in the hidden layer
reg, float - L2 regularization strength
"""
self.reg = reg
self.n_input = n_input
self.n_output = n_output
self.h_size = hidden_layer_size
# TODO Create necessary layers
self.RL = ReLULayer()
self.FC1 = FullyConnectedLayer(n_input=self.n_input,
n_output=self.h_size)
self.FC2 = FullyConnectedLayer(self.h_size, self.n_output)
