def __init__(self):
""" Initializes model layers and weights. """
# <COGINST>
init_kwargs = {'gain': np.sqrt(2)}
self.conv1 = conv(200, 250, 2, stride = 1, weight_initializer = glorot_normal, weight_kwargs = init_kwargs)
self.dense1 = dense(250, 250, weight_initializer = glorot_normal, weight_kwargs = init_kwargs)
self.dense2 = dense(250,1, weight_initializer = glorot_normal, weight_kwargs = init_kwargs)
def __init__(self):
self.conv1 = conv(1,
5,
2,
2,
stride=2,
padding=0,
weight_initializer=glorot_uniform)
self.conv2 = conv(5,
10,
2,
2,
stride=1,
padding=0,
weight_initializer=glorot_uniform)
self.dense1 = dense(360, 300, weight_initializer=glorot_uniform)
self.dense2 = dense(300, 300, weight_initializer=glorot_uniform)
self.dense3 = dense(300, 5, weight_initializer=glorot_uniform)
self.layers = (self.conv1, self.conv2, self.dense1, self.dense2,
self.dense3)
self.tensors = []
for layer in self.layers:
for parameter in layer.parameters:
self.tensors.append(parameter)
self.weights = [parameter.data for parameter in self.tensors]
def __init__(self, input_dim, f1, f2, d1, num_classes):
'''
Parameters
----------
input_dim:
size of input based on training data
n1 : int
The number of neurons in the first hidden layer
num_classes : int
The number of classes predicted by the model'''
init_kwargs = {'gain': np.sqrt(2)}
self.conv1 = conv(input_dim,
f1,
5,
5,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.conv2 = conv(f1,
f2,
5,
5,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.dense1 = dense(f2 * 37 * 37,
d1,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.dense2 = dense(d1,
num_classes,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
def __init__(self):
params = np.load("params.npy")
#this gain is a parameter for the weight initializiation function glorot_uniform
#which you can read more about in the documentation, but it isn't crucial for now
#If you would like to read more about how Xavier Glorot explains the rationalization behind these weight initializations,
#look here for his paper written with Yoshua Bengio. (http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf)
init_kwargs = {'gain': np.sqrt(2)}
#We will use a dropout probability of 0.5 so that values are randomly set to 0 in our data
self.dropout_prob = 0.5
#initialize your two dense and convolution layers as class attributes using the functions imported from MyNN
#We will use weight_initializer=glorot_uniform for all 4 layers
#You know the input size of your first convolution layer. Try messing around with the output size but make sure that the following
#layers dimmensions line up. For your first convolution layer start with input = 1, output = 20, filter_dims = 5, stride = 5,
#padding = 0
self.dense1 = dense(180,
200,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.dense2 = dense(200,
10,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.conv1 = conv(1,
20, (5, 5),
stride=1,
padding=0,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.conv2 = conv(20,
20, (2, 2),
stride=2,
padding=0,
weight_initializer=glorot_uniform,
weight_kwargs=init_kwargs)
self.dropout = dropout(self.dropout_prob)
self.conv1.weight = Tensor(params[0])
self.conv1.bias = Tensor(params[1])
self.conv2.weight = Tensor(params[2])
self.conv2.bias = Tensor(params[3])
self.dense1.weight = Tensor(params[4])
self.dense1.bias = Tensor(params[5])
self.dense2.weight = Tensor(params[6])
self.dense2.bias = Tensor(params[7])
def __init__(self):
self.dense1 = dense(2 * 68, 100, weight_initializer=glorot_normal)
self.dense1.weight = new_parameters[0]
self.dense1.bias = new_parameters[1]
self.dense2 = dense(100, 10, weight_initializer=glorot_normal)
self.dense2.weight = new_parameters[2]
self.dense2.bias = new_parameters[3]
self.dense3 = dense(10, 3, weight_initializer=glorot_normal)
self.dense3.weight = new_parameters[4]
self.dense3.bias = new_parameters[5]
def __init__(self):
self.conv1 = conv(1,
10,
5,
padding=0,
weight_initializer=glorot_uniform)
self.conv2 = conv(5,
20,
5,
padding=0,
weight_initializer=glorot_uniform)
self.dense1 = dense(290, 20, weight_initializer=glorot_uniform)
self.dense2 = dense(20, 2, weight_initializer=glorot_uniform)
def __init__(self):
'''Hidden words is the hidden layer for each word iteration
Hidden sentence is the hidden layer for each sentence iteration
llayers is a list of all the layers
L = length of embbedding array
Unknown Words is a safety in case the word is not in the embedding
GRUU is the update function of the GRU
GRUR is the reset function of the GRU
'''
L = 0
self.L = L
self.hiddenwordsF = [np.zeros((L))]
self.hiddensentenceF = [np.zeros((L))]
self.hiddenwordsB = [np.zeros((L))]
self.hiddensentenceB = [np.zeros((L))]
self.llayers = []
self.unknownwords = []
self.GRUUW = dense(L, L)
self.GRURW = dense(L, L)
self.GRUHW = dense(L, L)
self.GRUUS = dense(L, L)
self.GRURS = dense(L, L)
self.GRUHS = dense(L, L)
self.EntireDocument = dense(2 * L,
) # Used for the logistical binary layer
self.Content = dense(2 * L)
self.salience
self.novelty
self.AbsolutePos
self.RelativePos
def __init__(self, d_data, d_embed):
"""
Initializes the layers in the model.
Parametersv
----------
d_desc : int
dimension of the descriptor vector.
d_embed : int
dimension of the embedding
"""
self.dense1 = dense(d_data, 1500, weight_initializer=normal)
self.dense2 = dense(1500, 1000, weight_initializer=normal)
self.dense3 = dense(1000, d_embed, weight_initializer=normal)
def __init__(self, d_in, d_out):
"""
:param d_in: int dimensions in
:param d_out: int dimensions out
"""
self.dense1 = dense(d_in, d_out, weight_initializer=glorot_normal)
def __init__(self):
self.conv1 = conv(1,
50,
3,
3,
stride=1,
weight_initializer=glorot_uniform)
self.conv2 = conv(50,
20,
3,
3,
stride=1,
weight_initializer=glorot_uniform)
self.dense1 = dense(180, 50, weight_initializer=glorot_uniform)
self.dense2 = dense(50, 29, weight_initializer=glorot_uniform)
pass
def __init__(self, dim_input, dim_recurrent, dim_output):
""" Initializes all layers needed for RNN
Parameters
----------
dim_input: int
Dimensionality of data passed to RNN (C)
dim_recurrent: int
Dimensionality of hidden state in RNN (D)
dim_output: int
Dimensionality of output of RNN (K)
"""
self.fc_x2h = dense(dim_input,
dim_recurrent,
weight_initializer=glorot_normal)
self.fc_h2h = dense(dim_recurrent,
dim_recurrent,
weight_initializer=glorot_normal,
bias=False)
self.fc_h2y = dense(dim_recurrent,
dim_output,
weight_initializer=glorot_normal)
self.Uz = mg.Tensor(
np.random.randn(dim_input * dim_recurrent).reshape(
dim_input, dim_recurrent))
self.Wz = mg.Tensor(
np.random.randn(dim_recurrent * dim_recurrent).reshape(
dim_recurrent, dim_recurrent))
self.bz = mg.Tensor(np.random.randn(dim_recurrent))
self.Ur = mg.Tensor(
np.random.randn(dim_input * dim_recurrent).reshape(
dim_input, dim_recurrent))
self.Wr = mg.Tensor(
np.random.randn(dim_recurrent * dim_recurrent).reshape(
dim_recurrent, dim_recurrent))
self.br = mg.Tensor(np.random.randn(dim_recurrent))
self.Uh = mg.Tensor(
np.random.randn(dim_input * dim_recurrent).reshape(
dim_input, dim_recurrent))
self.Wh = mg.Tensor(
np.random.randn(dim_recurrent * dim_recurrent).reshape(
dim_recurrent, dim_recurrent))
self.bh = mg.Tensor(np.random.randn(dim_recurrent))
def __init__(self, dim_input: int, dim_output: int):
"""
Initializes the Img2Caption Linear Encoder
Parameters
----------
dim_input the dimensions of the input descriptor
dim_output the dimensions of the encoded value
"""
self.layer = dense(dim_input, dim_output)
def __init__(self, dim_input, dim_recurrent, dim_output):
""" Initializes all layers needed for RNN
Parameters
----------
dim_input: int
Dimensionality of data passed to RNN (C)
dim_recurrent: int
Dimensionality of hidden state in RNN (D)
dim_output: int
Dimensionality of output of RNN (K)
"""
self.fc_x2h = dense(dim_input, dim_recurrent, weight_initializer=glorot_normal)
self.fc_h2h = dense(
dim_recurrent, dim_recurrent, weight_initializer=glorot_normal, bias=False
)
self.fc_h2y = dense(dim_recurrent, dim_output, weight_initializer=glorot_normal)
def __init__(self):
#Check this: the 3s-- kernel size
gain = {'gain': np.sqrt(2)}
self.conv1 = conv(3, 20, (5,5), weight_initializer=glorot_uniform,
weight_kwargs=gain)
self.conv2 = conv(20, 10, (5,5), weight_initializer=glorot_uniform,
weight_kwargs=gain)
#Check the dimensions on this:
self.dense3 = dense(49000 , 232, weight_initializer=glorot_uniform,
weight_kwargs=gain)
def __init__(self):
self.conv1 = conv(1,
50, (5, 5),
stride=5,
weight_initializer=glorot_uniform,
weight_kwargs=gain)
self.conv2 = conv(50,
20, (2, 2),
stride=2,
weight_initializer=glorot_uniform,
weight_kwargs=gain)
self.dense1 = dense(500,
50,
weight_initializer=glorot_uniform,
weight_kwargs=gain)
self.dense2 = dense(50,
29,
weight_initializer=glorot_uniform,
weight_kwargs=gain)
pass
def __init__(self, dim_in=48, num_out=7, load=False):
self.conv1 = conv(1, 32, 2, 2, stride=1, padding=0, weight_initializer=Model.init)
self.conv2 = conv(32, 64, 3, 3, stride=2, padding=1, weight_initializer=Model.init)
self.conv3 = conv(64, 128, 2, 2, stride=2, weight_initializer=Model.init)
self.conv4 = conv(128, 256, 3, 3, stride=3, weight_initializer=Model.init)
self.dense1 = dense(256, 512, weight_initializer=Model.init)
self.dense2 = dense(512, num_out, weight_initializer=Model.init)
if (load):
data = np.load("data/npmodelParam.npz")
self.conv1.weight = data["l1w"]
self.conv1.bias = data["l1b"]
self.conv2.weight = data["l2w"]
self.conv2.bias = data["l2b"]
self.conv3.weight = data["l3w"]
self.conv3.bias = data["l3b"]
self.conv4.weight = data["l4w"]
self.conv4.bias = data["l4b"]
self.dense1.weight = data["l5w"]
self.dense1.bias = data["l5b"]
self.dense2.weight = data["l6w"]
self.dense2.bias = data["l6b"]
def __init__(self, dim_input, dim_output):
"""This initializes the layer for our Linear Encoder, and sets it
as an attribute of the model.
Parameters
----------
dim_input : int
The size of our input
dim_output : int
The size of the output layer
"""
self.layer = dense(dim_input, dim_output)
def __init__(self, d_feature, d_embed):
"""
Initializes all of the layers in our model and sets
them as attributes of the model.
Parameters
----------
d_feature : int
The dimension of the image feature vector.
d_embed : int
The dimension of the semantic embedding (i.e. the reduced
dimensionality).
"""
self.encode = dense(d_feature, d_embed, weight_initializer=normal)
def __init__(self, dim_input=512, dim_encoded=50):
"""This initializes the single layer in our model, and sets it
as an attribute of the model.
Parameters
----------
dim_input : int
the size of the inputs
dum_encoded : int
the size of the outputs of the encoded layer
"""
self.dense1 = dense(dim_input, dim_encoded, weight_initializer=he_normal)
def __init__(
self, dim_input,
dim_output): #default dim_input should be 512, output should be 50
""" Initializes all layers needed for RNN
Parameters
----------
dim_input: int
Dimensionality of data passed to RNN
dim_output: int
Dimensionality of output of RNN
"""
self.dense1 = dense(dim_input,
dim_output,
weight_initializer=he_normal)
def __init__(self):
self.dense1 = dense(512, 50)
def __init__(self, dim_in, num_hidden, dim_out): self.d1 = dense(dim_in, num_hidden, weight_initializer=glorot_normal) self.d2 = dense(num_hidden, dim_out, weight_initializer=glorot_normal)
def __init__(self):
""" This initializes all of the layers in our model, and sets them
as attributes of the model.
"""
self.dense1 = dense(512, 50)
def __init__(self, dim_input, dim_output):
""" Initialize the model. """
self.layer = dense(dim_input, dim_output, weight_initializer=normal)
def __init__(self, D_full, D_out):
self.dense1 = dense(D_full,
D_out,
weight_initializer=he_normal,
bias=True)
def __init__(self,num_in, num_out):
self.dense=dense(num_in, num_out, weight_initializer=glorot_normal)
def __init__(self):
self.dense1 = dense(1, 20, weight_initializer=normal)
self.dense2 = dense(20, 30, weight_initializer=normal)
self.dense3 = dense(30, 20, weight_initializer=normal)
self.dense4 = dense(20, 1, weight_initializer=normal)
