def SentimentNet(word_to_idx):
"""Construct a RNN model for sentiment analysis
# Arguments:
word_to_idx: A dictionary giving the vocabulary. It contains V entries,
and maps each string to a unique integer in the range [0, V).
# Returns
model: the constructed model
"""
vocab_size = len(word_to_idx)
print("vocab_size", vocab_size)
model = Model()
model.add(
FCLayer(vocab_size,
200,
name='embedding',
initializer=Guassian(std=0.01)))
model.add(
BidirectionalRNN(
RNNCell(in_features=200, units=50,
initializer=Guassian(std=0.01))))
model.add(FCLayer(100, 32, name='fclayer1',
initializer=Guassian(std=0.01)))
model.add(TemporalPooling()) # defined in layers.py
model.add(FCLayer(32, 2, name='fclayer2', initializer=Guassian(std=0.01)))
return model
def MNISTNet():
conv1_params = {
'kernel_h': 3,
'kernel_w': 3,
'pad': 0,
'stride': 1,
'in_channel': 1,
'out_channel': 6
}
conv2_params = {
'kernel_h': 3,
'kernel_w': 3,
'pad': 0,
'stride': 1,
'in_channel': 6,
'out_channel': 16
}
pool1_params = {
'pool_type': 'max',
'pool_height': 2,
'pool_width': 2,
'stride': 2,
'pad': 0
}
pool2_params = {
'pool_type': 'max',
'pool_height': 3,
'pool_width': 3,
'stride': 2,
'pad': 0
}
model = Model()
model.add(
Convolution(conv1_params,
name='conv1',
initializer=Guassian(std=0.001)))
model.add(ReLU(name='relu1'))
model.add(Pooling(pool1_params, name='pooling1'))
model.add(
Convolution(conv2_params,
name='conv2',
initializer=Guassian(std=0.001)))
model.add(ReLU(name='relu2'))
model.add(Pooling(pool2_params, name='pooling2'))
model.add(Dropout(ratio=0.25, name='dropout1'))
model.add(Flatten(name='flatten'))
model.add(
FCLayer(400, 256, name='fclayer1', initializer=Guassian(std=0.01)))
model.add(ReLU(name='relu3'))
# model.add(Dropout(ratio=0.5))
model.add(FCLayer(256, 10, name='fclayer2',
initializer=Guassian(std=0.01)))
return model
def MNISTNet1():
print("BESTNET")
conv1_params={
'kernel_h': 3,
'kernel_w': 3,
'pad': 0,
'stride': 1,
'in_channel': 1,
'out_channel': 32
}
conv2_params={
'kernel_h': 3,
'kernel_w': 3,
'pad': 0,
'stride': 1,
'in_channel': 32,
'out_channel': 32
}
pool1_params={
'pool_type': 'max',
'pool_height': 2,
'pool_width': 2,
'stride': 2,
'pad': 0
}
pool2_params={
'pool_type': 'max',
'pool_height': 3,
'pool_width': 3,
'stride': 2,
'pad': 0
}
model = Model()
# fan_in = in_channel * kernel_h * kernel_w
# fan_out = num_filters * kernel_h * kernel_w / Pooling_layer_area
model.add(Convolution(conv1_params, name='conv1', initializer=Guassian(std=0.001)))
model.add(ReLU(name='relu1'))
model.add(Pooling(pool1_params, name='pooling1'))
model.add(Convolution(conv2_params, name='conv2', initializer=Guassian(std=0.001)))
model.add(ReLU(name='relu2'))
model.add(Pooling(pool2_params, name='pooling2'))
model.add(Dropout(ratio=0.25, name='dropout1'))
model.add(Flatten(name='flatten'))
model.add(FCLayer(800, 256, name='fclayer1', initializer=Guassian(std=0.01)))
model.add(ReLU(name='relu3'))
model.add(FCLayer(256, 10, name='fclayer2', initializer=Guassian(std=0.01)))
return model
def build(height, width, depth, classes, batch_size):
# initialize the input shape
input_shape = (batch_size, height, width, depth)
# initialize the model
model = Model()
# input layer
model.add(Input(input_shape, name="input"))
# first CONV => RELU => POOL block
model.add(Conv2D(96, (11, 11), padding_type="same", name="conv_1-1"))
model.add(ReLU(name="relu_1-1"))
model.add(MaxPooling2D((3, 3), stride=(2, 2), name="pool_1"))
# second CONV => RELU => POOL block
model.add(Conv2D(256, (5, 5), padding_type="same", name="conv_2-1"))
model.add(ReLU(name="relu_2-1"))
model.add(MaxPooling2D((3, 3), stride=(2, 2), name="pool_2"))
# first (and only) ( CONV => RELU ) * 3 => POOL block
model.add(Conv2D(384, (3, 3), padding_type="same", name="conv-3_1"))
model.add(ReLU(name="relu_3-1"))
model.add(Conv2D(384, (3, 3), padding_type="same", name="conv_3-2"))
model.add(ReLU(name="relu_3-2"))
model.add(Conv2D(256, (3, 3), padding_type="same", name="conv_3-3"))
model.add(ReLU(name="relu_3-3"))
model.add(MaxPooling2D((3, 3), stride=(2, 2), name="pool_3"))
# flatten layer
model.add(Flatten(name="flatten"))
# softmax classifier
model.add(Dense(classes, name="dense_1"))
model.add(Softmax(name="softmax"))
# return the constructed network architecture
return model
def build(height, width, depth, classes, batch_size):
# construct the input shape tuple
input_shape = (batch_size, height, width, depth)
# instantiate the model
model = Model()
# input layer
model.add(Input(input_shape=input_shape, name="input"))
# first CONV => RELU => POOL block
model.add(Conv2D(20, (5, 5), padding_type="same", name="conv_1"))
model.add(ReLU(name="relu_1"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_1"))
# second CONV => RELU => POOL block
model.add(Conv2D(50, (5, 5), padding_type="same", name="conv_2"))
model.add(ReLU(name="relu_2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_2"))
# first and only set of FC => RELU layers
model.add(Flatten(name="flatten"))
model.add(Dense(500, name="fc_1"))
model.add(ReLU(name="relu_3"))
# softmax classifier
model.add(Dense(classes, name="fc_2"))
model.add(Softmax(name="softmax"))
# return the constructed network architecture
return model
from nnfs.datasets import spiral_data
from layers import *
from activations import *
from losses import *
from optimizers import *
from models import Model
from accuracy import *
nnfs.init()
# Create dataset
X, y = spiral_data(samples=1000, classes=3)
X_test, y_test = spiral_data(samples=100, classes=3)
model = Model()
model.add(
Dense_Layer(2, 512, weight_regularizer_l2=5e-4, bias_regularizer_l2=5e-4))
model.add(Activation_ReLU())
model.add(Dropout_Layer(0.1))
model.add(Dense_Layer(512, 3))
model.add(Activation_Softmax())
model.set(loss=Loss_CategoricalCrossentropy(),
optimizer=Optimizer_Adam(learning_rate=0.05, decay=5e-5),
accuracy=Accuracy_Categorical())
model.finalize()
model.train(X,
y,
validation_data=(X_test, y_test),
epochs=10000,
print_every=100)
def build(height, width, depth, classes, batch_size):
# construct the input shape tuple
input_shape = (batch_size, height, width, depth)
# instantiate the model
model = Model()
# input layer
model.add(Input(input_shape=input_shape, name="input"))
# first CONV => RELU => CONV => RELU => POOl block
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
padding_type="same",
name="conv_1-1"))
model.add(ReLU(name="relu_1-1"))
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
padding_type="same",
name="conv_1-2"))
model.add(ReLU(name="relu_1-2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_1"))
# second CONV => RELU => CONV => RELU => POOl block
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
padding_type="same",
name="conv_2-1"))
model.add(ReLU(name="relu_2-1"))
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
padding_type="same",
name="conv_2-2"))
model.add(ReLU(name="relu_2-2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_2"))
# third CONV => RELU => CONV => RELU => POOl block
model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
padding_type="same",
name="conv_3-1"))
model.add(ReLU(name="relu_3-1"))
model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
padding_type="same",
name="conv_3-2"))
model.add(ReLU(name="relu_3-2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_3"))
# first CONV => RELU => CONV => RELU => CONV => RELU => POOL
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_4-1"))
model.add(ReLU(name="relu_4-1"))
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_4-2"))
model.add(ReLU(name="relu_4-2"))
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_4-2"))
model.add(ReLU(name="relu_4-2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_4"))
# second CONV => RELU => CONV => RELU => CONV => RELU => POOL
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_5-1"))
model.add(ReLU(name="relu_5-1"))
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_5-2"))
model.add(ReLU(name="relu_5-2"))
model.add(
Conv2D(filters=512,
kernel_size=(3, 3),
padding_type="same",
name="conv_5-2"))
model.add(ReLU(name="relu_5-2"))
model.add(
MaxPooling2D(kernel_size=(2, 2), stride=(2, 2), name="pool_5"))
# flatten layer
model.add(Flatten(name="flatten"))
# softmax classifier
model.add(Dense(units=classes, name="dense_1"))
model.add(Softmax(name="softmax_1"))
# return the constructed model architecture
return model
