def mutate(self):
filtersMutator = FiltersRangeMutator(8, 128)
config = self.__model.get_config()
for layer in config['layers']:
if random.uniform(0, 1) > 0.3 and layer['class_name'] == 'Conv2D':
layer_config = layer['config']
layer_config['filters'] = filtersMutator.mutate(
layer_config['filters'])
mutated_model = Sequential.from_config(config)
print("SequentialModelGene has been mutated")
self.__model = mutated_model
return SequentialModelGene(self.__seed,
mutated_model) # TODO or return self
def __init__(
self,
q_network,
min_training_history_size,
gamma,
target_q_network_update_interval,
callbacks=None,
):
self.training_q_network = q_network
self.target_q_network = Sequential.from_config(
q_network.get_config(), custom_objects={"NoisyDense": NoisyDense})
self.min_training_history_size = min_training_history_size
self.gamma = gamma
self.epsilon = 1.0
self.target_q_network_update_interval = target_q_network_update_interval
if callbacks is None:
callbacks = []
self.callback_group = AgentCallbackGroup(callback_group=callbacks)
def test_config_deserialisation(self):
# class MyClass:
# def __init__(self, foo, bar):
# self.foo = foo
# self.bar = bar
#
# def __eq__(self, other):
# if not isinstance(other, MyClass):
# # don't attempt to compare against unrelated types
# return NotImplemented
#
# return self.foo == other.foo and self.bar == other.bar
#
# self.assertEqual(MyClass('foo', 'bar'), MyClass('foo', 'bar'))
seed = 1234
tf.random.set_seed(seed)
model = Sequential()
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Dropout(0.25, seed=seed))
model.add(
Dense(12,
input_dim=8,
activation='relu',
kernel_initializer='glorot_uniform',
seed=seed))
model.add(Dense(8, activation='relu', seed=seed))
model.add(Dense(1, activation='sigmoid', seed=seed))
config = model.get_config()
deserialized_model = Sequential.from_config(config)
# self.assertEqual(model, deserialized_model)
self.assertEqual(model.layers[0].input.shape,
deserialized_model.layers[0].input.shape)
def load_sequential_model_from_file(model_file_path):
return Sequential.from_config(model_file_path)
from flask import Flask, jsonify
from keras import Sequential
import scrape
import myMongo
import pickle
import pandas
app = Flask(__name__)
with open('myModel.bin', 'rb') as file:
config = pickle.load(file)
model = Sequential.from_config(config)
##Evaluate is used on newly scraped data
def evaluate(data):
data = pandas.DataFrame(data, index=[6])
data = data.values
prediction, probability = model.predict_classes(data), model.predict(data)
probability = float(probability[0][0]) * 100
prediction = int(prediction[0][0])
return prediction, probability
@app.route('/<string:name>')
def evaluateName(name):
##First query the db
try:
x = myMongo.queryUname(name)
except:
