def __init__(self):
global model
model = Sequential()
model.add(
Conv2D(64, (5, 5),
input_shape=(64, 64, 1),
activation='relu',
padding='same'))
model.add(Conv2D(64, (5, 5), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(10, activation='softmax'))
model.load_weights('model/bangla_1.h5')
class CNNMobiFallNet(object):
def __init__(self,
n_timestamps,
n_features,
n_outputs,
pretrained_path=None):
self.model = Sequential()
self.model.add(
TimeDistributed(Conv1D(filters=64,
kernel_size=3,
activation='relu'),
input_shape=(None, n_timestamps, n_features)))
self.model.add(
TimeDistributed(
Conv1D(filters=64, kernel_size=3, activation='relu')))
self.model.add(TimeDistributed(Dropout(0.5)))
self.model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
self.model.add(TimeDistributed(Flatten()))
self.model.add(LSTM(100))
self.model.add(Dropout(0.5))
self.model.add(Dense(100, activation='relu'))
self.model.add(Dense(n_outputs, activation='softmax'))
if pretrained_path != None:
self.model.load_weights(pretrained_path)
print('Loading weights from {}'.format(pretrained_path))
# optimizer = SGD(lr=0.01, momentum=0.9, nesterov=True)
adam = Adam(lr=0.001)
self.model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
def get_model(self):
print(self.model.summary())
return self.model
def __init__(self, restore=None, session=None, use_log=False):
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Flatten(input_shape=(28, 28, 1)))
model.add(Dense(1024))
model.add(Lambda(lambda x: x * 10))
model.add(Activation('softplus'))
model.add(Lambda(lambda x: x * 0.1))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.layer_outputs = layer_outputs
self.model = model
def __generator_cnn(self):
model = Sequential([
Dense(math.ceil(self.width / 8) * math.ceil(self.height / 8) * 256,
input_shape=[100]),
BatchNormalization(),
LeakyReLU(),
Reshape(
(math.ceil(self.width / 8), math.ceil(self.height / 8), 256)),
Conv2DTranspose(128, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
output_padding=(self.height % 2, self.width % 2)),
BatchNormalization(),
LeakyReLU(),
Conv2DTranspose(64, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
output_padding=(self.height % 2, self.width % 2)),
BatchNormalization(),
LeakyReLU(),
Conv2DTranspose(1, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
activation='tanh',
output_padding=(self.height % 2, self.width % 2))
])
info(model.summary())
if os.path.exists(self.gen_output_model_path):
info("Loading generator weights.")
model.load_weights(self.gen_output_model_path)
return model
def train(X, labels):
X_train, X_test, y_train, y_test = train_test_split(X,
labels,
test_size=0.2,
random_state=0)
mlb = MultiLabelBinarizer(classes=[
'Heavy Metal', 'Thrash Metal', 'Power Metal', 'Folk Metal',
'Progressive Metal', 'Death Metal', 'Doom Metal', 'Black Metal', 'Rock'
])
y_train = [each for each in y_train]
y_train = mlb.fit_transform(y_train)
y_test = [each for each in y_test]
y_test = mlb.fit_transform(y_test)
model = Sequential()
model.add(Dense(256, activation='relu', input_shape=(1305, )))
model.add(Dropout(0.5))
model.add(Dense(128, activation='relu'))
model.add(Dense(9, activation='sigmoid'))
mcp_save = ModelCheckpoint('best_mlp.h5',
save_best_only=True,
monitor='val_f1_m',
mode='max')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=7,
verbose=1,
epsilon=1e-4,
mode='min')
EarlyStopping(monitor='val_loss',
min_delta=0.001,
patience=5,
verbose=0,
mode='min')
opt = Adam(lr=0.01)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['acc', f1_m])
model.fit(X_train,
y_train,
batch_size=64,
epochs=50,
verbose=2,
validation_data=(X_test, y_test),
callbacks=[mcp_save, reduce_lr_loss])
model.load_weights('best_mlp.h5')
preds = model.predict(X_test)
preds[preds >= 0.5] = 1
preds[preds < 0.5] = 0
print(classification_report(y_test, preds))
print(hamming_loss(y_test, preds))
print(accuracy_score(y_test, preds))
def build_model(self):
model = Sequential()
model.add(Dense(150, input_dim=self.states, activation='relu'))
model.add(Dense(150, activation='relu'))
model.add(Dense(150, activation='relu'))
model.add(Dense(self.actions, activation='softmax'))
model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
if self.load_weights:
model.load_weights(self.weights_path)
return model
def init():
global model, graph, session
model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(6, )))
model.add(Dense(32, activation='relu'))
model.add(Dense(2, activation='linear'))
model.compile(loss='mse', optimizer='adam', metrics=['mae'])
model.load_weights("training_1/cp.ckpt")
model._make_predict_function()
session = K.get_session()
graph = tf.get_default_graph()
def index(request):
prior = ResNet50(include_top=False,
weights='imagenet',
input_shape=(224, 224, 3))
model = Sequential()
model.add(prior)
model.add(tf.keras.layers.GlobalAveragePooling2D(name='GA'))
model.add(Flatten(name='Flatten'))
model.add(Dense(1024, activation='linear', name='Dense1'))
model.add(Dense(512, activation='linear', name='Dense2'))
model.add(Dense(256, activation='linear', name='Dense3'))
model.add(Dense(128, activation='linear', name='Dense4'))
model.add(Dense(64, activation='linear', name='Dense5'))
model.add(Dense(42, activation='softmax', name='Output'))
opt = tf.keras.optimizers.RMSprop()
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=[tf.keras.metrics.TopKCategoricalAccuracy(1)])
model.load_weights(
os.path.join(settings.BASE_DIR, 'weights', 'weights.hdf5'))
if request.method == "POST":
try:
shutil.rmtree(os.path.join(settings.BASE_DIR, 'media'))
except:
pass
f = request.FILES['sentFile'] # here you get the files needed
response = {}
file_name = "pic.jpg"
name = default_storage.save(file_name, f)
response['file_url'] = default_storage.url(name)
datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1. /
255)
generator = datagen.flow_from_directory(os.path.join(
settings.BASE_DIR, 'media'),
target_size=(224, 224),
batch_size=128,
shuffle=False,
class_mode=None)
generator.reset()
pred = model.predict(generator)
label = np.argmax(pred[0])
response['score'] = pred[0][label]
detail = pd.read_csv(
os.path.join(settings.BASE_DIR, 'category_detail', 'detail.csv'))
response['name'] = detail['detail'][detail['code'] == label].values[0]
return render(request, 'index.html', response)
else:
return render(request, 'index.html')
def discriminator(self):
D = Sequential()
D.add(Masking(mask_value=0, input_shape=(200, 20)))
D.add(LSTM(20, return_sequences=True))
D.add(LSTM(20))
D.add(Dense(1, activation='sigmoid'))
if self.load_weights:
D.load_weights('current_best_classifier.hdf5')
D.compile(optimizer=Adam(learning_rate=0.0001),
loss='binary_crossentropy',
metrics=['accuracy'])
return D
def model(output, checkpoint):
'''
This function contains deep learning model consisting of CNN and LSTM layers. CNN is used for extracting useful
features from the image pixels and LSTM is used to remember sequence of frames.
input shape : (number of frames, image width, image height, channel) - eg. (12,200,200,3)
output : number of classes - (no of exercise that we wish to classify)
checkpoint : relative path of checkpoint file (.pkl)
'''
model = Sequential()
model.add(TimeDistributed(Conv2D(16, (5, 5)), input_shape=shape))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(4, 4), padding='same')))
model.add(TimeDistributed(Conv2D(32, (3,3), padding='same')))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(2, 2))))
model.add(TimeDistributed(Conv2D(64, (3,3), padding='same')))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(2, 2))))
model.add(TimeDistributed(Conv2D(128, (3,3), padding='same')))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(2, 2))))
model.add(TimeDistributed(Conv2D(64, (3,3), padding='same')))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(2, 2))))
model.add(TimeDistributed(Conv2D(32, (3,3), padding='same')))
model.add(TimeDistributed(LeakyReLU(alpha=0.05)))
model.add(TimeDistributed(MaxPooling2D((2, 2), strides=(2, 2))))
# extract features and dropout
model.add(TimeDistributed(Flatten()))
model.add(Dropout(0.3))
# input to LSTM
model.add(LSTM(256, return_sequences=False, dropout=0.3))
# classifier with sigmoid activation for multilabel
model.add(Dense(output, activation='softmax'))
model.load_weights(checkpoint)
optimizer = optimizers.Adam(0.0005)
model.compile(optimizer,'categorical_crossentropy', metrics=['acc'] )
return model
def main_thread():
global power
# FCN
labels = [i for i in range(19)]
model = Sequential()
model.add(layers.Dense(40, activation='relu'))
model.add(layers.Dense(50, activation='relu'))
model.add(layers.Dense(40, activation='relu'))
model.add(layers.Dense(30, activation='relu'))
model.add(layers.Dense(len(labels), activation='softmax'))
model.build(input_shape=(None, 40))
model.load_weights('./weights/my_model.h5')
while True:
# print('show')
# Load signals file
AMOUNT = 200
time, data = getSignalLogs(amount=AMOUNT)
# plot(time, data)
# Do the bias and absolution
BIAS = 173.5
data = np.abs(data - BIAS)
# Grouping
THRESHOLD = 4
STEP_NUM = 5
PACK_NUM = 30
low_samples, high_samples = np.copy(data), np.copy(data)
high_samples[data <= THRESHOLD] = 0
low_samples[data > THRESHOLD] = 0
FIX_INPUT_NUMBER = 40
groups = list()
for ginx in range(0, len(data) - PACK_NUM, STEP_NUM):
groups.append(
np.mean(
np.convolve(low_samples[ginx:ginx + PACK_NUM],
high_samples[ginx:ginx + PACK_NUM])))
if len(groups) < (FIX_INPUT_NUMBER * 0.7):
continue
else:
groups = np.array(
groups + [0 for i in range(FIX_INPUT_NUMBER - len(groups))])
p = model.predict(np.array([
groups,
])).tolist()[0]
power = 9 - abs(p.index(max(p)) - 9)
print(power)
class Predictor:
def __init__(self, model_name):
with open(f'models/{model_name}/class_names.txt',
'r',
encoding='utf-8') as f:
self.class_names = f.readline().rstrip().split(',')
self.cleaner = Cleaner()
self.model = None
self.load_model(model_name)
def predict(self, text_list):
"""return list of class predictions based on list of strings"""
if not text_list or text_list == ['']:
return None
text_list = [self.cleaner.clean_text(text) for text in text_list]
prediction_result = self.model.predict(text_list)
probabilities = [(key, sum(map(itemgetter(i), prediction_result)))
for i, key in enumerate(self.class_names)]
return sorted(probabilities, key=itemgetter(1), reverse=True)
def load_model(self, model_name):
try:
with open(f'models/{model_name}/params.txt', 'r') as f:
max_features = int(f.readline())
sequence_length = int(f.readline())
embedding_dim = int(f.readline())
except FileNotFoundError:
max_features = 20000
sequence_length = 40
embedding_dim = 160
vectorize_layer = TextVectorization(
max_tokens=max_features,
output_mode='int',
output_sequence_length=sequence_length)
# ATTENTION: this model MUST be absolutely
# identical to the original one
self.model = Sequential([
vectorize_layer,
Sequential([
layers.Embedding(max_features + 1, embedding_dim),
layers.Dropout(0.3),
layers.GlobalAveragePooling1D(),
layers.Dropout(0.3),
layers.Dense(len(self.class_names))
])
])
self.model.load_weights(f'models/{model_name}/checkpoint')
self.model.predict(["define", "input", "shape"])
class CartPoleModel:
def __init__(self):
self.model = Sequential()
self.model.add(Dense(24, activation="relu", input_shape=(4,)))
self.model.add(Dense(24, activation="relu"))
self.model.add(Dense(2))
self.model.compile(optimizer='nadam', loss='mse')
self.history = deque(maxlen=10000)
def get_action(self, state, epsilon=0, verbose=0):
if random.random() < epsilon:
chosen_action = random.choice((0, 1))
if verbose: print(state, '!!', chosen_action)
return chosen_action
q_values = self.model.predict(np.reshape(state, [1, 4]))[0]
chosen_action = np.argmax(q_values)
if verbose: print(state, '=>', chosen_action, q_values)
return chosen_action
def remember(self, entry):
self.history.append(entry)
def load(self):
try:
self.model.load_weights('cartpole_model.hd5')
print('Loaded!')
except Exception as e:
print(e)
def save(self):
self.model.save_weights('cartpole_model.hd5')
def learn(self, batch_size=64, discount=.9, verbose=0):
if len(self.history) < batch_size: return
batch = random.sample(self.history, batch_size)
foo = zip(*batch)
states, actions, rewards, state_nexts, dones = foo
states = np.reshape(states, [batch_size, 4])
state_nexts = np.reshape(state_nexts, [batch_size, 4])
state_preds = self.model.predict(states)
state_next_preds = self.model.predict(state_nexts)
for idx, action in enumerate(actions):
q_learned = rewards[idx]
if not dones[idx]:
q_learned += discount * np.amax(state_next_preds[idx])
state_preds[idx][action] = q_learned
self.model.fit(states, state_preds, verbose=verbose)
def __generator(self):
model = Sequential([
LSTM(4, input_shape=[32, 32]),
BatchNormalization(),
LeakyReLU(),
Dense(self.width * self.height * self.channels, activation='tanh'),
Reshape((self.width, self.height, self.channels))
])
if os.path.exists(self.gen_output_model_path):
model.build()
info("Loading generator weights.")
model.load_weights(self.gen_output_model_path)
return model
def __generator_nn(self):
model = Sequential([
Dense(1024, input_shape=[100]),
BatchNormalization(),
LeakyReLU(),
Dense(256, activation='relu'),
Dense(self.width * self.height * self.channels, activation='tanh'),
Reshape((self.width, self.height, self.channels))
])
info(model.summary())
if os.path.exists(self.gen_output_model_path):
info("Loading generator weights.")
model.load_weights(self.gen_output_model_path)
return model
def load(self, batch_size=16, filename=None):
if filename is None:
filename = f"model.MNIST.h5"
f = hw4_utils.find_file(filename)
self.build()
model = Sequential(self.layers)
model.build(input_shape=(batch_size, 28, 28, 1))
model.load_weights(f)
self.layers = model.layers
self._define_ops()
def __init__(self,
restore=None,
session=None,
use_log=False,
use_brelu=False):
def bounded_relu(x):
return K.relu(x, max_value=1)
if use_brelu:
activation = bounded_relu
else:
activation = 'relu'
self.num_channels = 1
self.image_size = 28
self.num_labels = 10
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Activation(activation))
model.add(Conv2D(32, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(200))
model.add(Activation(activation))
model.add(Dense(10))
# output log probability, used for black-box attack
if use_log:
model.add(Activation('softmax'))
if restore:
model.load_weights(restore)
layer_outputs = []
for layer in model.layers:
if isinstance(layer, Conv2D) or isinstance(layer, Dense):
layer_outputs.append(
K.function([model.layers[0].input], [layer.output]))
self.model = model
self.layer_outputs = layer_outputs
def load(self):
print('bigan load model')
#module = hub.Module(r"E:\Deep learning\pest\model\inception_model")
module = hub.Module('/root/inception_model')
resnet = hub.KerasLayer(module, input_shape=(299, 299, 3), output_shape=[2048])
model = Sequential([
resnet,
Dense(5, activation=softmax)
])
model.compile(optimizer='adam', loss=sparse_categorical_crossentropy, metrics=['accuracy'])
model.summary()
model.load_weights('/root/inceptionv16_wights.keras')
return model
def LSTM(lstm_pretrained=True,
lstm_pretrained_fname='lstm5_epch240_tts10_bs1000_129_17759.h5'):
"""
If using a pretrained model,
set lstm_pretrained = True,
and set lstm_pretrained_fname to the pretrained weights.
"""
RNN = Sequential([
LSTM(90, return_sequences=True, input_shape=(7, 1)),
Attention(return_sequences=True),
LSTM(90),
Dense(1, activation=None)
])
if lstm_pretrained == True:
RNN.load_weights(pretrained_fname)
return RNN
def transfer_model(self,nclasses1,nclasses2,path,name="EfficientNetB6",pool="gem",suffix = ""):
inp = layers.Input(shape=(self.height,self.width, 3),name="input")
pretrained_model = models[name](weights = None, include_top = False,
input_shape = [self.height,self.width, 3], input_tensor = inp)
model = Sequential([
inp, pretrained_model,self.poolings[pool],
layers.Dense(self.embed_size, activation=None, kernel_initializer="glorot_normal",
dtype=tf.float32,name = "feature"+suffix),
ArcFace(nclasses1,dtype=tf.float32,name = "ArcFace"+suffix)
])
model.load_weights(path)
model = Sequential([
*model.layers[:-1],
ArcFace(nclasses2,dtype=tf.float32,name = "ArcFace"+suffix)
],name = "%s_%s_ArcFace_more"%(name,pool))
return model
def load_parametric_model(activation, optimizer, lr, n_hidden_layers,
n_weights, batch_size, n_epochs):
model = Sequential()
model.add(Dense(10, input_shape=(5, )))
for i in range(n_hidden_layers):
model.add(Dense(n_weights, activation=activation))
model.add(Dense(5))
model.compile(loss='mse', optimizer=optimizer(lr=lr), metrics=['mape'])
if os.path.isfile('data/keras_model.index'):
print("Keras model weights loaded")
model.load_weights('data/keras_model')
else:
print("Keras model not found!")
return model
def get_model():
model = Sequential([
Embedding(input_dim=vocab_size,
output_dim=emb_dim,
input_length=max_sent_len,
trainable=False),
Bidirectional(
LSTM(64, return_sequences=False, recurrent_activation='sigmoid')),
Dropout(0.5),
Dense(2, activation='softmax')
])
model.load_weights(WEIGHTS_PATH)
model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def __discriminator(self, path):
model = Sequential([
GaussianNoise(1.5,
input_shape=(self.width, self.height,
self.channels)),
Conv2D(filters=128, kernel_size=(3, 3), padding='same'),
LeakyReLU(alpha=0.2),
MaxPool2D(2, 2),
Dropout(0.25),
Flatten(),
Dense(255, activation='relu'),
Dense(1, activation='sigmoid')
])
if os.path.exists(path):
info("Loading discriminator weights.")
model.load_weights(path)
return model
def __generator(self, path):
model = Sequential([
Conv2D(filters=128,
kernel_size=(5, 5),
strides=(3, 3),
padding='same',
input_shape=(self.width, self.height, self.channels)),
LeakyReLU(alpha=0.2),
MaxPool2D(2, 2),
BatchNormalization(momentum=0.8),
Flatten(),
Dense(5012, activation='relu'),
Dense(self.width * self.height * self.channels, activation='tanh'),
Reshape((self.width, self.height, self.channels))
])
if os.path.exists(path):
info("Loading generator weights.")
model.load_weights(path)
return model
def load_parametric_model_avg(activation,
optimizer, lr, n_hidden_layers, n_weights, batch_size, n_epochs, input_shape):
model = Sequential()
for i in range(n_hidden_layers):
if i==0:
model.add(Dense(n_weights, activation=activation, input_shape=(input_shape,)))
else:
model.add(Dense(n_weights, activation=activation))
model.add(Dense(9))
model.compile(loss='mse', optimizer=optimizer(lr=lr), metrics=['mape'])
if os.path.isfile('../data/keras_model_avg_best.index'):
print ("Best Keras model weights loaded")
model.load_weights('../data/keras_model_avg_best')
elif os.path.isfile('../data/keras_model.index'):
print ("Keras model weight loaded")
modal.load_weights('../data/keras_model')
else:
print ("Keras model not found!")
return model
def train(X, labels):
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.2, random_state=0)
encoder = LabelEncoder()
y_train = encoder.fit_transform(y_train)
y_test = encoder.transform(y_test)
onehot = OneHotEncoder(sparse=False)
y_train = onehot.fit_transform(y_train.reshape(len(y_train), 1))
y_test_oh = onehot.transform(y_test.reshape(len(y_test), 1))
class_weights = [class_freq[label] for label in encoder.classes_]
model = Sequential()
model.add(Dense(256, activation='relu', input_shape=(1305,)))
model.add(Dropout(0.5))
model.add(Dense(128, activation='relu'))
model.add(Dense(9, activation='softmax'))
mcp_save = ModelCheckpoint('best_mlp.h5', save_best_only=True, monitor='val_f1_m', mode='max')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, epsilon=1e-4, mode='min')
EarlyStopping(monitor='val_loss', min_delta=0.001, patience=5, verbose=0, mode='min')
opt = Adam(lr=0.01)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['acc', f1_m])
model.fit(X_train, y_train, batch_size=64, epochs=50, verbose=2,
validation_data=(X_test, y_test_oh), callbacks=[mcp_save, reduce_lr_loss],
class_weight=class_weights)
model.load_weights('best_mlp.h5')
preds = model.predict(X_test)
preds = np.argmax(preds, axis=1)
score_macro = f1_score(y_test, preds, average="macro")
score_micro = f1_score(y_test, preds, average="micro")
print("F1_macro:{0}, F1_micro:{1}".format(score_macro, score_micro))
print(classification_report(y_test, preds))
class MobiFallNet(object):
def __init__(self, input_shape, n_outputs, pretrained_path=None):
self.model = Sequential()
self.model.add(
LSTM(100, input_shape=input_shape, return_sequences=True))
self.model.add(Dropout(0.2))
self.model.add(LSTM(100))
self.model.add(Dropout(0.2))
self.model.add(Dense(100, activation='relu'))
self.model.add(Dense(n_outputs, activation='softmax'))
if pretrained_path != None:
self.model.load_weights(pretrained_path)
print('Loading weights from {}'.format(pretrained_path))
optimizer = SGD(lr=0.001, momentum=0.9, nesterov=True)
# adam = Adam(lr=0.001)
self.model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
def get_model(self):
print(self.model.summary())
return self.model
def getModel():
#forming model
model = Sequential()
#adding layers and forming the model
model.add(
Conv2D(64,
kernel_size=5,
strides=1,
padding="Same",
activation="relu",
input_shape=(40, 5, 1)))
model.add(MaxPooling2D(padding="same"))
model.add(
Conv2D(128,
kernel_size=5,
strides=1,
padding="same",
activation="relu"))
model.add(MaxPooling2D(padding="same"))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(256, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(512, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(5, activation="softmax"))
# model.add(Dense(10,activation="softmax"))
# model.add(Dense(11,activation="softmax"))
#compiling
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
#loading
# model.load_weights('../Classifier/modelv1.hdf5')
# model.load_weights('../Classifier/modelv0.hdf5')
model.load_weights('../Classifier/modelv2.hdf5')
return model
class FacialExpressionModel(object):
emotion_dict = [
"Angry", "Disgusted", "Fearful", "Happy", "Neutral", "Sad", "Surprised"
]
def __init__(self, model_weights_file):
self.loaded_model = Sequential()
self.loaded_model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=(48, 48, 1)))
self.loaded_model.add(Conv2D(64, kernel_size=(3, 3),
activation='relu'))
self.loaded_model.add(MaxPooling2D(pool_size=(2, 2)))
self.loaded_model.add(Dropout(0.25))
self.loaded_model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu'))
self.loaded_model.add(MaxPooling2D(pool_size=(2, 2)))
self.loaded_model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu'))
self.loaded_model.add(MaxPooling2D(pool_size=(2, 2)))
self.loaded_model.add(Dropout(0.25))
self.loaded_model.add(Flatten())
self.loaded_model.add(Dense(1024, activation='relu'))
self.loaded_model.add(Dropout(0.5))
self.loaded_model.add(Dense(7, activation='softmax'))
self.loaded_model.load_weights(model_weights_file)
self.loaded_model._make_predict_function()
def predict_emotion(self, img):
self.preds = self.loaded_model.predict(img)
return FacialExpressionModel.emotion_dict[int(np.argmax(self.preds))]
def build_advanced_net(model_weights=None,
image_size: int = 224,
classes: int = 7) -> Sequential:
conv_base = VGG16(include_top=False,
weights='imagenet',
input_shape=(image_size, image_size, 3))
for layer in conv_base.layers[:-2]:
layer.trainable = False
model = Sequential()
model.add(conv_base)
model.add(GlobalAveragePooling2D())
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(64, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(classes, activation='softmax'))
if model_weights is not None:
model.load_weights(model_weights)
return model
