def build_local_critic(self):
local_critic = Sequential()
local_critic.add(
Dense(24,
input_shape=(self.state_size, ),
activation='relu',
kernel_initializer='he_uniform'))
local_critic.add(
Dense(12, activation='relu', kernel_initializer='he_uniform'))
local_critic.add(
Dense(self.value_size,
activation='linear',
kernel_initializer='he_uniform'))
local_critic._make_predict_function()
local_critic.set_weights(self.g_critic.get_weights())
return local_critic
def __init__(self, *args, **kwargs):
super(MyServer, self).__init__(*args, **kwargs)
total_word_count = 0
f = open('../../data/anthem.txt', 'r')
anthem_text, count = self.text_to_data(f.read(), "ayn rand")
total_word_count += count
f = open('../../data/mobydick.txt', 'r')
mobydick_text, count = self.text_to_data(f.read(), "herman melville")
total_word_count += count
f = open('../../data/alice.txt', 'r')
alice_text, count = self.text_to_data(f.read(), 'lewis carroll')
total_word_count += count
total_arr = anthem_text + mobydick_text + alice_text
np.random.seed(53894343)
np.random.shuffle(total_arr)
self.total_dict = {
"text": [x[0] for x in total_arr],
"author": [x[1] for x in total_arr]
}
total_df = pd.DataFrame(self.total_dict)
#print(total_df.describe())
self.train_input, self.test_input, self.train_label, self.test_label, self.x_train, self.x_test, self.y_train, self.y_test, self.tokenizer, self.text_labels, self.num_classes = self.init_data(
total_df, total_word_count, .7)
model = Sequential([
Dense(512),
Activation('sigmoid'),
Dense(self.num_classes),
Activation('softmax')
])
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(self.x_train,
self.y_train,
epochs=20,
batch_size=64,
verbose=1,
validation_split=0.05)
model._make_predict_function()
self.model = model
def _build_model(self):
# Neural Net for Deep-Q learning Model
model = Sequential()
model.add(Dense(24, input_dim=self.state_size, activation='tanh'))
model.add(Dense(24, activation='tanh'))
model.add(Dense(self.action_size, activation='linear'))
model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
target_model = Sequential()
target_model.add(
Dense(24, input_dim=self.state_size, activation='tanh'))
target_model.add(Dense(24, activation='tanh'))
target_model.add(Dense(self.action_size, activation='linear'))
target_model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
model._make_predict_function()
target_model._make_predict_function()
return model, target_model
def get_model():
global model
global graph
vgg16_model = keras.applications.vgg16.VGG16()
model = Sequential()
for i in vgg16_model.layers:
model.add(i)
for layer in model.layers:
layer.trainable = False
model.add(Dense(4, activation='softmax'))
model.load_weights("model_weights.h5")
model._make_predict_function()
graph = tf.get_default_graph()
print("Model loaded!")
def build_model(self):
actor, critic = Sequential()
actor.add(Dense(self.network_structure[0], input_shape=(self.input_size,), init='lecun_uniform'))
actor.add(LeakyReLU(alpha=0.01))
for idx in range(1, len(self.network_structure)):
layerSize = self.network_structure[idx]
actor.add(Dense(layerSize, init="lecun_uniform"))
actor.add(LeakyReLU(alpha=0.01))
actor.add(LSTM(self.network_structure[-1], dropout_W=0.2, dropout_U=0.2))
critic = actor
actor.add(Dense(self.output_size, init='lecun_uniform'))
actor.add(Activation("softmax"))
critic.add(Dense(1))
critic.add(Activation("linear"))
'''
input = Input(shape=(self.input_size,))
conv = Conv2D(16, (8, 8), strides=(4, 4), activation='relu')(input) # transfer from convolution networks to dense networks
conv = Conv2D(32, (4, 4), strides=(2, 2), activation='relu')(conv)
conv = Flatten()(conv)
fc = Dense(256, activation='relu')(conv)
ls = LSTM(256, dropout_W=0.2, dropout_U=0.2)(fc) # add LSTM cells
policy = Dense(self.output_size, activation='softmax')(ls)
value = Dense(1, activation='linear')(ls)
actor = Model(inputs=input, outputs=policy)
critic = Model(inputs=input, outputs=value)
'''
actor._make_predict_function()
critic._make_predict_function()
actor.summary()
critic.summary()
return actor, critic
from keras.preprocessing import image
import numpy as np
import os
from PIL import Image
images = []
path1=r"G:\study\machine learning\competition\analytics Vidya Computer Vision\test_real\\"
for img in os.listdir(r"G:\study\machine learning\competition\analytics Vidya Computer Vision\test_real"):
img = image.load_img(path1+img, target_size=(192, 192))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
images.append(img)
# stack up images list to pass for prediction
images = np.vstack(images)
classifier = tf.keras.models.load_model(r"G:\study\machine learning\competition\analytics Vidya Computer Vision\model3.h5")
classifier._make_predict_function()
classes=classifier.predict(images)
pred=[]
for i in range(0,len(classes)):
pred.append(classes[i].argmax(axis=0)+1)
import pandas as pd
z=os.listdir(r"G:\study\machine learning\competition\analytics Vidya Computer Vision\test_real")
data=pd.DataFrame(list(zip(z,pred)),columns=['image','category']).to_csv(r"G:\study\machine learning\competition\analytics Vidya Computer Vision\Solution3.csv")
class StockLSTM(BaseModel):
def __init__(self,
num_classes,
window_length,
weights_file='weights/lstm.h5'):
self.model = None
self.weights_file = weights_file
self.num_classes = num_classes
self.window_length = window_length
def build_model(self, load_weights=True):
""" Load training history from path
Args:
load_weights (Bool): True to resume training from file or just deploying.
Otherwise, training from scratch.
Returns:
"""
if load_weights:
self.model = keras.models.load_model(self.weights_file)
print('Successfully loaded model')
else:
self.model = Sequential()
self.model.add(
keras.layers.LSTM(20,
input_shape=(self.num_classes,
self.window_length)))
self.model.add(Dense(64))
self.model.add(Dropout(0.5))
self.model.add(Dense(64))
self.model.add(Dropout(0.5))
self.model.add(Dense(self.num_classes, activation='softmax'))
self.model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=1e-4),
metrics=['accuracy'])
print('Built model from scratch')
self.model._make_predict_function()
self.graph = tf.get_default_graph()
def train(self, X_train, Y_train, X_val, Y_val, verbose=True):
continue_train = True
while continue_train:
self.model.fit(X_train,
Y_train,
batch_size=128,
epochs=50,
validation_data=(X_val, Y_val),
shuffle=True,
verbose=verbose)
save_weights = input('Type True to save weights\n')
if save_weights:
self.model.save(self.weights_file)
continue_train = input(
"True to continue train, otherwise stop training...\n")
print('Finish.')
def evaluate(self, X_test, Y_test, verbose=False):
return self.model.evaluate(X_test, Y_test, verbose=verbose)
def predict(self, X_test, verbose=False):
return self.model.predict(X_test, verbose=verbose)
def predict_single(self, observation):
""" Predict the action of a single observation
Args:
observation: (num_stocks + 1, window_length)
Returns: a single action array with shape (num_stocks + 1,)
"""
action = np.zeros((self.num_classes, ))
obsX = observation[:, -self.window_length:,
3] / observation[:, -self.window_length:, 0]
obsX = normalize(obsX)
obsX = np.expand_dims(obsX, axis=0)
with self.graph.as_default():
current_action_index = self.model.predict_classes(obsX,
verbose=False)
action[current_action_index] = 1.0
return action
def predictValue():
img_width, img_height = 210, 210
epochs = 10
batch_size = 32
if K.image_data_format() == 'channels_first':
input_shape = (3, img_width, img_height)
else:
input_shape = (img_width, img_height, 3)
# In[3]:
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(210,210,3)))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(5))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
train_datagen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=False)
# this is the augmentation configuration we will use for testing
test_datagen = ImageDataGenerator(rescale=1. / 255)
model.load_weights("model/Final.h5")
model._make_predict_function()
# In[6]:
classList = ['corn gray leaf spot', 'corn common rust', 'corn healthy', 'peach bacterial spot', 'peach healthy']
datagen = ImageDataGenerator(rescale=1. / 255)
generator = datagen.flow_from_directory(
'imagedata',
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode='categorical', # only data, no labels
shuffle=False) # keep data in same order as labels
op = model.predict_generator(generator,1)
maxprobability = max(op[0])
for i in range(len(op[0])):
if maxprobability == op[0][i]:
maxprobabilityclass = i
break
K.clear_session()
del model
if maxprobability < 0.5:
return str("image is not discernible")
return str(classList[maxprobabilityclass])
# Plot the train and val curve
# In[15]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
model._make_predict_function()
#Train and validation accuracy
#plt.plot(epochs, acc, 'b', label='Training accurarcy')
#plt.plot(epochs, val_acc, 'r', label='Validation accurarcy')
#plt.title('Training and Validation accurarcy')
#plt.legend()
#plt.figure()
#Train and validation loss
#plt.plot(epochs, loss, 'b', label='Training loss')
#plt.plot(epochs, val_loss, 'r', label='Validation loss')
#plt.title('Training and Validation loss')
#plt.legend()
#plt.show()
def __init__(self,
playerID,
game,
is_ai=True,
model=None,
train=None,
nb_frames=None,
name='Alice',
stack=5000):
self.game = game
self.daemon = True
if model is not None:
self.model = model
elif is_ai:
grid_size = 66
hidden_size = 32
nb_frames = 5
lstm_size = 64
batch_size = 5000
model = Sequential()
model.add(
LSTM(lstm_size,
return_sequences=True,
input_shape=(nb_frames, grid_size)))
model.add(Dropout(0.2))
model.add(LSTM(int(lstm_size / 2), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(int(lstm_size / 4)))
model.compile(RMSprop(), 'MSE')
model._make_predict_function()
if model is not None:
assert len(
model.output_shape
) == 2, "Model's output shape should be (nb_samples, nb_actions)."
if not nb_frames and not model.input_shape[1]:
raise Exception("Missing argument : nb_frames not provided")
elif not nb_frames:
nb_frames = model.input_shape[1]
elif model.input_shape[
1] and nb_frames and model.input_shape[1] != nb_frames:
raise Exception(
"Dimension mismatch : time dimension of model should be equal to nb_frames."
)
self.model = model
self.nb_frames = nb_frames
self.frames = None
self.train = train
self.nb_actions = 3
self.playerID = playerID
self._name = name
self._stack = stack
self._originalstack = stack
self._hand = []
self.add_player()
self.last_S = None
model=Sequential()
for layer in v_model.layers[:-1]:
model.add(layer)
for layer in model.layers:
layer.trainable=False
model.add(Dropout(0.4))
model.add(Dense(2,activation="softmax"))
model.load_weights('models/weights.h5')
# Load your trained model
#model = Sequential()
#model = load_model(MODEL_PATH)
model._make_predict_function() # Necessary
print('Model loaded. Start serving...')
# You can also use pretrained model from Keras
# Check https://keras.io/applications/
#from keras.applications.resnet50 import ResNet50
#model = ResNet50(weights='imagenet')
print('Model loaded. Check http://127.0.0.1:5000/')
def model_predict(img_path, model):
img = image.load_img(img_path, target_size=(224, 224))
# Preprocessing the image
x = image.img_to_array(img)
# x = np.true_divide(x, 255)
class DeepQNetwork(Representation):
def __init__(self,gridsize=5,actionspaceperagent=5,numberofagent=2,
hidden_unit=[12,12],learning_rate=0.1,
batch_size=32,trainpass=25,experiencebuffer=128,
train_period=1,
gamma = 0.99,
model_reset_counter=32,
memory_type = "SumTree"):
self.Gamma = gamma
self.batchsize = batch_size
self.trainPass = trainpass
self.hidden_unit = hidden_unit
self.learningrate = learning_rate
self.size_of_input_units = gridsize * gridsize * numberofagent
self.gridsize = gridsize
if memory_type=="Uniform":
self.memory = Memory_UniformRandom(experiencebuffer)
elif memory_type == "SumTree":
self.memory = Memory_SumTree(experiencebuffer)
self.fresh_experience_counter = 0
self.actionspaceforagent = actionspaceperagent
self.numberofagent = numberofagent
self.output_unit = actionspaceperagent**numberofagent
self.trainingepochtotal = 0
self.train_period = train_period # After how many new experience we will run fitting/training.
self.counter_experience = 0 # A counter to hold how many tuple experienced
self.counter_modelReset = model_reset_counter
# create model
self.model = Sequential()
self.model.add(Dense(self.hidden_unit[0], activation='tanh', input_dim = self.size_of_input_units ))
for i in range(1, len(hidden_unit)):
self.model.add(Dense(self.hidden_unit[i], activation='tanh'))
self.model.add(Dense(self.output_unit, activation=LeakyReLU(0.3)))
# Compile model
self.model.compile(loss='mse', optimizer='sgd', metrics=['accuracy'])
self.model._make_predict_function()
#save the TensorFlow graph:
self.graph = tf.get_default_graph()
self.model.summary()
self.modelFreezed = self.model;
self.modelFreezed.summary()
if os.path.isfile("modeltrained.h5"):
self.model.load_weights("modeltrained.h5")
print("###############################")
print("Existing model loaded.......")
print("###############################")
self.model.save_weights("modelinit.h5")
# Reset the batch
self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
def Convert_State_To_Input(self,state):
# Create zero filled output value
outValue = np.zeros(shape=(self.numberofagent,self.gridsize,self.gridsize))
# Convert list to numpy array
state = np.reshape(state,(1,state.shape[0]))
# Decompose states
states = np.split(state[0],self.numberofagent)
# Fill output tensor with agents position
for i in range(self.numberofagent) :
row = int(states[i][0])
col = int(states[i][1])
outValue[i,row,col] = 1
return outValue.flatten()
def Get_Greedy_Pair(self,state):
# Backward compability: Preprocess state input if needed.
if np.size(state) != self.size_of_input_units:
values = self.ForwardPass(self.Convert_State_To_Input(state))
else:
values = self.ForwardPass(state)
# Get the maximums
arg = values.argmax()
valmax = values.max()
return arg,valmax
def Get_Value(self,state,action):
values = self.ForwardPass(self.Convert_State_To_Input(state))
index = self.Get_Action_Index(action)
temp = values[index]
return temp
def ForwardPass(self,input):
# Form Input Values
input = np.reshape(input,(1,input.shape[0]))
# Prediction of the model
with self.graph.as_default():
hypothesis = self.modelFreezed.predict(input)
values = np.asarray(hypothesis).reshape(self.output_unit)
return values
def ForwardPassQ2(self,input):
# Form Input Values
input = np.reshape(input,(1,input.shape[0]))
# Prediction of the model
with self.graph.as_default():
hypothesis = self.model.predict(input)
values = np.asarray(hypothesis).reshape(self.output_unit)
return values
def Get_Greedy_PairQ2(self,state):
# Backward compability: Preprocess state input if needed.
if np.size(state) != self.size_of_input_units:
values = self.ForwardPassQ2(self.Convert_State_To_Input(state))
else:
values = self.ForwardPassQ2(state)
# Get the maximums
arg = values.argmax()
valmax = values.max()
return arg,valmax
def Set_Value(self,state,action,value):
# Preprocess State
inputVal = self.Convert_State_To_Input(state)
# Update label
values = self.ForwardPass(inputVal)
index = self.Get_Action_Index(action)
values[index] = value
# Append new sample to Memory of Experiences
# Don't worry about its size, since it is a queue
self.memory.add((inputVal, values))
#if self.fresh_experience_counter == self.batchsize :
if len(self.memory) >= self.batchsize :
self.trainingepochtotal += self.trainPass
# print('Training Epoch:', self.trainingepochtotal)
# Get Unique Samples from memory as much as batchsize
minibatch = random.sample(list(self.memory), self.batchsize)
for i in np.arange(len(minibatch)):
X, Y = minibatch[i]
self.batchSamplesX = np.vstack((self.batchSamplesX, X))
self.batchSamplesY = np.vstack((self.batchSamplesY, Y))
with self.graph.as_default():
self.model.fit(self.batchSamplesX, self.batchSamplesY, epochs=self.trainPass, batch_size= self.batchsize, verbose=0)
# Reset the batch
self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
def Get_Action_Index(self, action):
sizeOfAction = action.shape[0]
temp = 0
for i in np.arange(sizeOfAction):
temp = temp + action[i] * (self.actionspaceforagent**(sizeOfAction-i-1))
return temp;
def Add_Experience(self,state,action,nextstate,reward,status):
self.counter_experience += 1
if self.counter_experience % self.counter_modelReset == 0:
self.modelFreezed = self.model
# WORKING
arg_Qmax, Qmax = self.Get_Greedy_Pair(nextstate)
QValue = reward + self.Gamma * Qmax
self.Set_Value(state,action,QValue)
# WORKING
# state = self.Convert_State_To_Input(state)
# nextstate = self.Convert_State_To_Input(nextstate)
# action = self.Get_Action_Index(action)
# values=0
# self.memory.append((state,action,reward,nextstate,status,values))
#
# if len(self.memory) >= self.batchsize:
#
# self.trainingepochtotal += self.trainPass
#
# minibatch = self.Memory_Sample_UniformRandom()
#
# for state, action, reward, nextstate, status, values in minibatch :
#
# if status==1 :
# value = reward
# else :
# # arg_Qmax, Qmax = self.Get_Greedy_Pair(nextstate)
#
# arg_Q2max, Q2max = self.Get_Greedy_PairQ2(nextstate)
#
# Q_Update = self.ForwardPass(nextstate)[arg_Q2max]
#
# value = reward + self.Gamma * Q_Update
#
# values = self.ForwardPass(state)
# values[action] = value
#
# self.batchSamplesX = np.vstack((self.batchSamplesX, state))
# self.batchSamplesY = np.vstack((self.batchSamplesY, values))
#
# with self.graph.as_default():
# self.model.fit(self.batchSamplesX, self.batchSamplesY, epochs=self.trainPass,
# batch_size=self.batchsize, verbose=0)
#
# # Reset the batch
# self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
# self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
# NOT WORKING
# time_Full = time.time()
# self.memory.append((state,action,reward,nextstate,status))
#
# # if self.fresh_experience_counter == self.batchsize :
# if len(self.memory) >= self.batchsize:
#
# self.trainingepochtotal += self.trainPass
#
#
# # Get Unique Samples from memory as much as batchsize
# minibatch = random.sample(list(self.memory), self.batchsize)
#
# time_Loop = time.time()
#
# for i in np.arange(len(minibatch)):
# state, action, reward, nextstate, status = minibatch[i]
#
# arg_Qmax, Qmax = self.Get_Greedy_Pair(nextstate)
# QValue = reward + self.Gamma * Qmax
#
# processed_state = self.Convert_State_To_Input(state)
# values = self.ForwardPass(processed_state)
#
# index = self.Get_Action_Index(action)
# values[index] = QValue
#
# self.batchSamplesX = np.vstack((self.batchSamplesX, processed_state))
# self.batchSamplesY = np.vstack((self.batchSamplesY, values))
#
# print("For Loop: %s seconds" % (time.time() - time_Loop)) # 0.12662458419799805 seconds
#
# time_Fit = time.time()
# with self.graph.as_default():
# self.model.fit(self.batchSamplesX, self.batchSamplesY, epochs=self.trainPass, batch_size=self.batchsize,
# verbose=0)
# print("Get_Fit: %s seconds" % (time.time() - time_Fit)) # 0.12662458419799805 seconds
#
# # Reset the batch
# self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
# self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
#
# print("Get_Full: %s seconds" % (time.time() - time_Full)) # 0.12662458419799805 seconds
# NOT WORKING
# Transform our states to new form then store them.
# state = self.Convert_State_To_Input(state)
# nextstate = self.Convert_State_To_Input (nextstate)
# self.memory.append((state,action,reward,nextstate,status))
# self.counter_experience+=1
#
# if len(self.memory) >= self.batchsize and self.counter_experience % self.train_period == 0 :
# self.Network_Train()
def Network_Train(self):
print("Network Train Called..")
# NOT WORKING #2
# minibatch = self.Memory_Sample_UniformRandom()
# for i in range(self.batchsize):
#
# state, action, reward, nextstate, status = minibatch[i]
#
# action_id = self.Get_Action_Index(action)
#
# Qtarget = self.ForwardPass(self.Convert_State_To_Input(state))
#
# if status == 1:
# Qtarget[action_id] = reward
# else:
# arg_Qmax, Qmax = self.Get_Greedy_Pair(nextstate)
# Qtarget[action_id] = reward + self.Gamma * Qmax
#
# self.batchSamplesX = np.vstack((self.batchSamplesX, self.Convert_State_To_Input(state)))
# self.batchSamplesY = np.vstack((self.batchSamplesY, Qtarget))
#
# with self.graph.as_default():
# self.model.fit(self.batchSamplesX, self.batchSamplesY, epochs=self.trainPass, batch_size=self.batchsize,verbose=0)
#
# # Reset the batch
# self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
# self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
# NOT WORKING #1
# minibatch = self.Memory_Sample_UniformRandom()
# #states, actions, rewards, nextstates, stats = zip(*minibatch)
#
# states = np.vstack(np.array(minibatch)[:, 0])
# actions = np.vstack(np.array(minibatch)[:, 1])
# rewards = np.vstack(np.array(minibatch)[:, 2])
# nextstates = np.vstack(np.array(minibatch)[:, 3])
# stats = np.vstack(np.array(minibatch)[:, 4])
#
# action_ids = np.zeros(shape=(self.batchsize, 1))
# for i in range(self.batchsize):
# action_ids[i, 0] = self.Get_Action_Index(actions[i])
#
# # Prediction of the model
# with self.graph.as_default():
#
# # Predictions
# Qpredicted = self.model.predict(nextstates)
# Qtarget = self.model.predict(states)
#
# for i in range(self.batchsize):
#
# action_id = int(action_ids[i, 0])
#
# if stats[i] == 1:
# Qtarget[i, action_id] = rewards[i, 0]
# else:
# arg_Qmax = np.argmax(Qpredicted[i, :])
# Qmax = np.max(Qpredicted[i, :])
# reward = rewards[i, 0]
#
# Qtarget[i, action_id] = reward + self.Gamma * Qmax
#
# self.model.fit(states, Qtarget, epochs=self.trainPass, batch_size=self.batchsize,
# verbose=0)
def Memory_Sample_UniformRandom(self):
return random.sample(list(self.memory),self.batchsize)
def Memory_Sample_PrioritizationProportional(self):
raise NotImplementedError()
def Memory_Sample_PrioritizationRankBased(self):
raise NotImplementedError()
def Save_Model(self):
with self.graph.as_default():
self.model.save_weights("modelOutput.h5")
print("###############################")
print("Model saved.......")
print("###############################")
def __del__(self):
print('Representation object died.')
def load_model_klasifikasi():
global klasifikasi, train_set, test_set, datanya, kelasnya, LOKASI_TRAINING, LOKASI_TESTING
global MODENYA, productionEpochnya, isLoadedDariModel
# Initializing the CNN
klasifikasi = Sequential()
#input the first convolution with 32 filter, (5x5) kernel, and input shape (64,64,3)
klasifikasi.add(
Convolution2D(
32, # number of filter layers
5, # y dimension of kernel (we're going for a 3x3 kernel)
5, # x dimension of kernel
input_shape=(64, 64, 3),
init='he_normal'))
# input activation function relu
klasifikasi.add(Activation('relu'))
# input subsampling layer (maxpooling) (2x2) for reduce data
klasifikasi.add(MaxPooling2D(pool_size=(2, 2)))
#input the second convolution with 32 filter, (5x5) kernel,
klasifikasi.add(
Convolution2D(
64, # number of filter layers
5, # y dimension of kernel (we're going for a 3x3 kernel)
5, # x dimension of kernel
init='he_normal'))
# input activation function relu
klasifikasi.add(Activation('relu'))
# input subsampling layer (maxpooling) (2x2) for reduce data
klasifikasi.add(MaxPooling2D(pool_size=(2, 2)))
#Input Flatten
klasifikasi.add(Flatten())
klasifikasi.add(Dense(150, activation='relu', init='he_normal'))
klasifikasi.add(Dropout(0.5))
klasifikasi.add(Dense(84, activation='relu', init='he_normal'))
klasifikasi.add(Dropout(0.5))
klasifikasi.add(Dense(jumlahKelas, activation='softmax', init='he_normal'))
print("Full Connection Between Hidden Layers and Output Layers Completed")
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_set = train_datagen.flow_from_directory(LOKASI_TRAINING,
target_size=(64, 64),
batch_size=20,
class_mode='categorical')
test_set = test_datagen.flow_from_directory(LOKASI_TESTING,
target_size=(64, 64),
batch_size=20,
class_mode='categorical')
if isLoadedDariModel == True:
namaFilenya = "modelKlasifikasi" + str(productionEpochnya) + ".h5"
if os.path.exists(namaFilenya):
klasifikasi = load_model(namaFilenya)
datanya = klasifikasi.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
else:
raise ValueError(
'Error: File Tidak Ada Harap Lakukan Training Terlebih Dahulu Sebelum Menggunakan Model'
)
else:
# compile CNN
klasifikasi.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
print(klasifikasi.summary())
print("Compiling Initiated")
if MODENYA == 'production':
tensorboard = TensorBoard(log_dir="logs/{}".format(time()))
datanya = klasifikasi.fit_generator(
train_set,
steps_per_epoch=hitungGambar(LOKASI_TRAINING),
epochs=productionEpochnya,
validation_data=test_set,
validation_steps=hitungGambar(LOKASI_TESTING),
callbacks=[tensorboard])
klasifikasi.save("modelKlasifikasi" + str(productionEpochnya) +
".h5")
test_steps_per_epoch = numpy.math.ceil(test_set.samples /
test_set.batch_size)
predictions = klasifikasi.predict_generator(
test_set, steps=test_steps_per_epoch)
predicted_classes = numpy.argmax(predictions, axis=1)
true_classes = test_set.classes
class_labels = list(test_set.class_indices.keys())
report = metrics.classification_report(true_classes,
predicted_classes,
target_names=class_labels)
print(report)
else:
print('Model Tidak Tersimpan')
gambarHasilLatih()
klasifikasi._make_predict_function()
print("Compiling Completed")
Embedding(vocab_size, embedding_size, input_length=max_len),
LSTM(256, return_sequences=True),
TimeDistributed(Dense(300))
])
final_model = Sequential([
Merge([image_model, caption_model], mode='concat', concat_axis=1),
Bidirectional(LSTM(256, return_sequences=False)),
Dense(vocab_size),
Activation('softmax')
])
#final_model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy'])
final_model.load_weights(path + 'time_inceptionV3.h5')
final_model._make_predict_function()
graph1 = tf.get_default_graph()
def predict_caption(image):
start_word = ["<start>"]
while True:
par_caps = [word2idx[i] for i in start_word]
par_caps = sequence.pad_sequences([par_caps],
maxlen=max_len,
padding='post')
e = encode(image)
global graph1
with graph1.as_default():
preds = final_model.predict([np.array([e]), np.array(par_caps)])
word_pred = idx2word[np.argmax(preds[0])]
for layer_dim in reversed([im_shape[-1]] + layer_dims[0:-1]):
AE.add(
Conv2DTranspose(layer_dim,
kernel_size,
strides=(2, 2),
padding='same',
activation='relu'))
#rmsprop works well for <=8 layers and < 8 base dim
AE.compile(optimizer='rmsprop', loss='mean_squared_error')
#adam works well with 8 layers 8 base dim
#AE.compile(optimizer='adam',loss='mean_squared_error')
#AE.compile(optimizer='sgd',loss='mean_squared_error')
AE._make_predict_function()
graph = K.get_session().graph
assert seq_len == 1, "I broke it and I don't care right now"
#Define image pre-processing function
def pre_process_im(im):
im = cv2.resize(im.copy(), im_shape[0:2])
im = (im.reshape((1, ) + im_shape).astype(np.float32) / 127.5) - 1
return im
def de_process_im(im):
#im = cv2.resize(im.copy(),win_size[0:2])
class StockCNN(BaseModel):
def __init__(self,
nb_classes,
window_length,
weights_file='weights/cnn.h5'):
self.model = None
self.weights_file = weights_file
self.nb_classes = nb_classes
self.window_length = window_length
def build_model(self, load_weights=True):
""" Load training history from path
Args:
load_weights (Bool): True to resume training from file or just deploying.
Otherwise, training from scratch.
Returns:
"""
if load_weights:
self.model = load_model(self.weights_file)
print('Successfully loaded model')
else:
self.model = Sequential()
self.model.add(
Conv2D(filters=32,
kernel_size=(1, 3),
input_shape=(self.nb_classes, self.window_length, 1),
activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(
Conv2D(filters=32,
kernel_size=(1, self.window_length - 2),
activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(Flatten())
self.model.add(Dense(64, activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(64, activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(self.nb_classes, activation='softmax'))
self.model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=1e-3),
metrics=['accuracy'])
print('Built model from scratch')
self.model._make_predict_function()
self.graph = tf.get_default_graph()
def train(self, X_train, Y_train, X_val, Y_val, verbose=True):
#continue_train = True
#while continue_train:
for episodes in range(1, 21):
print('Episode ', episodes)
self.model.fit(X_train,
Y_train,
batch_size=128,
epochs=10,
validation_data=(X_val, Y_val),
shuffle=True,
verbose=verbose)
# save_weights = input('Type True to save weights\n')
# if save_weights:
# self.model.save(self.weights_file)
# continue_train = input("True to continue train, otherwise stop training...\n")
self.model.save(self.weights_file)
print('Finish.')
def evaluate(self, X_test, Y_test, verbose=False):
return self.model.evaluate(X_test, Y_test, verbose=verbose)
def predict(self, X_test, verbose=False):
return self.model.predict(X_test, verbose=verbose)
def predict_single(self, observation):
""" Predict the action of a single observation
Args:
observation: (num_stocks + 1, window_length)
Returns: a single action array with shape (num_stocks + 1,)
"""
obsX = observation[:, -self.window_length:,
3:4] / observation[:, -self.window_length:, 0:1]
obsX = normalize(obsX)
obsX = np.expand_dims(obsX, axis=0)
with self.graph.as_default():
return np.squeeze(self.model.predict(obsX), axis=0)
def train(self, tsData, nb_epochs=40, batchSize=32):
"""
Trains the LSTM on the initial TimeSeries data.
tsData can be pandas object with DateTimeIndex or a numpy array
tsData: list with numbers or pandas series
nb_epochs: 20 maybe better
batchSize: 32 ok
"""
self.in_training = True
if self.batch_size != batchSize:
self.batch_size = batchSize
# if self.model is not None:
# print('Model is already trained')
# return
# TODO input validation
temp_df = pd.DataFrame(tsData).copy()
temp_df.columns = ['load']
temp_df['diff'] = temp_df.load.diff()
temp_df['outVal'] = temp_df.load.shift(-1)
# Scale the input train data
temp_scaler_load = StandardScaler()
temp_df['scaledLoad'] = temp_scaler_load.fit_transform(
temp_df[['load']])
temp_df['outVal'] = temp_scaler_load.transform(temp_df[['outVal']])
temp_scaler_diff = StandardScaler()
temp_df['scaledDiff'] = temp_scaler_diff.fit_transform(
temp_df[['diff']])
# Reshape the input to the desired form
df_train = temp_df[['scaledLoad', 'scaledDiff',
'outVal']].dropna().values
X, y = self.split_sequences(df_train, self.n_steps)
# Create LSTM Network
temp_model = Sequential()
temp_model.add(
LSTM(units=50,
activation='relu',
return_sequences=True,
input_shape=(self.n_steps, self.n_features)))
temp_model.add(Dropout(0.2))
temp_model.add(LSTM(units=50, activation='relu',
return_sequences=True))
temp_model.add(Dropout(0.2))
temp_model.add(LSTM(units=50, activation='relu',
return_sequences=True))
temp_model.add(Dropout(0.2))
temp_model.add(LSTM(units=50, activation='relu'))
temp_model.add(Dropout(0.2))
temp_model.add(Dense(units=1))
temp_model.compile(optimizer='adam', loss='mean_squared_error')
temp_model.fit(X,
y,
epochs=nb_epochs,
batch_size=self.batch_size,
verbose=2)
temp_model._make_predict_function()
while self.in_forecast:
print(
'Training is waiting for forecast finish to change the model')
self.in_change = True
self.model = temp_model
self.df = temp_df
self.scaler_diff = temp_scaler_diff
self.scaler_load = temp_scaler_load
self.in_change = False
self.in_training = False
'''
vgg_model_m._make_predict_function()
input_shape_m = vgg_model_m.output_shape[1]
model_m = Sequential()
model_m.add(vgg_model_m)
model_m.add(InputLayer(input_shape=(input_shape_m, )))
model_m.add(Dense(512, activation='relu', input_dim=input_shape))
model_m.add(Dropout(0.3))
model_m.add(Dense(512, activation='relu'))
model_m.add(Dropout(0.3))
model_m.add(Dense(multi_types, activation='softmax'))
sgd = keras.optimizers.SGD(lr=multi_lr)
model_m.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
model_m.load_weights("fit_multi.h5")
model_m._make_predict_function()
vgg_s = vgg16.VGG16(include_top=False,
weights='imagenet',
input_shape=input_shape)
output_s = vgg_s.layers[-1].output
output_s = keras.layers.Flatten()(output_s)
vgg_model_s = Model(vgg_s.input, output_s)
vgg_model_s._make_predict_function()
input_shape_s = vgg_model_s.output_shape[1]
model_s = Sequential()
model_s.add(InputLayer(input_shape=(input_shape_s, )))
model_s.add(Dense(512, activation='relu', input_dim=input_shape_s))
model_s.add(Dropout(0.3))
model_s.add(Dense(512, activation='relu'))
model_s.add(Dropout(0.3))
class DeepQNetwork_PrioritizedReplay_Target_LearnerThread(Representation):
def __init__(self,
gridsize=5,
actionspaceperagent=5,
numberofagent=2,
hidden_unit=[12, 12],
learning_rate=0.1,
batch_size=32,
trainpass=25,
experiencebuffer=128,
train_period=1,
gamma=0.99,
model_reset_counter=32,
statePreprocessType="Tensor",
convolutionLayer=False,
modelId="noid",
logfolder=""):
print("###############################")
print("DeepQNetwork_PrioritizedReplay_Target_LearnerThread")
print("###############################")
self.Gamma = gamma
self.batchsize = batch_size
self.trainPass = trainpass
self.hidden_unit = hidden_unit
self.learningrate = learning_rate
self.statePreprocessType = statePreprocessType
self.convolutionLayer = convolutionLayer
self.mutex = Lock()
if (statePreprocessType == "Tensor"):
self.size_of_input_units = gridsize * gridsize * numberofagent
elif (statePreprocessType == "Vector"):
self.size_of_input_units = 7 * numberofagent
# (x,y,a) for each agent
self.gridsize = gridsize
self.experiencebuffersize = experiencebuffer
self.memory = Memory_SumTree(experiencebuffer)
self.fresh_experience_counter = 0
self.actionspaceforagent = actionspaceperagent
self.numberofagent = numberofagent
self.output_unit = actionspaceperagent**numberofagent
self.trainingepochtotal = 0
self.train_period = train_period # After how many new experience we will run fitting/training.
self.counter_experience = 0 # A counter to hold how many tuple experienced
self.counter_modelReset = model_reset_counter
self.modelId = modelId
self.logfolder = logfolder
self.update_target_interval = 10000
self.experience_counter = 0
self.model = None
self.model_target = None
print("log/" + logfolder + "/model_0.h5")
if os.path.isfile("log/" + self.logfolder + "/model_0.h5"):
print("###############################")
print("Existing model is being loaded.......")
print("###############################")
self.model = load_model("log/" + self.logfolder + "/model_0.h5")
else:
print("###############################")
print("Not Any Existing model found.......")
print("###############################")
if self.model is None:
# create model
self.model = Sequential()
if self.convolutionLayer == True:
self.convolution_input = (self.numberofagent, self.gridsize,
self.gridsize)
self.model.add(
Conv2D(16, (2, 2),
strides=(1, 1),
activation='relu',
input_shape=(self.convolution_input),
data_format='channels_first'))
self.model.add(
Conv2D(32, (2, 2), strides=(1, 1), activation='relu'))
#self.model.add(Conv2D(64, (3, 3), activation='relu'))
self.model.add(Flatten())
self.model.add(Dense(self.hidden_unit[0], activation='tanh'))
else:
self.model.add(
Dense(self.hidden_unit[0],
activation='tanh',
input_dim=self.size_of_input_units))
for i in range(1, len(hidden_unit)):
self.model.add(Dense(self.hidden_unit[i], activation='tanh'))
self.model.add(Dense(self.output_unit, activation='relu'))
# Compile model
self.model.compile(loss='mse',
optimizer='sgd',
metrics=['accuracy'])
self.model._make_predict_function()
if os.path.isfile("log/" + self.logfolder + "/model_weight_0.h5"):
self.model.load_weights("log/" + self.logfolder +
"/model_weight_0.h5")
print("###############################")
print("Existing model params are loaded.......")
print("###############################")
# save the TensorFlow graph:
self.graph = tf.get_default_graph()
self.model.summary()
self.model_target = clone_model(self.model)
self.Update_target()
# self.Save_Model()
self.model.save_weights("log/" + self.logfolder + "/modelinit_" +
self.modelId + ".h5")
# Reset the batch
self.Reset_Batch()
# Initialize thread parameters
self.flag_continue = True
#_thread.start_new_thread(self.Learner, ())
self._thread = Thread(target=self.Learner, args=())
self._thread.start()
def Update_target(self):
print('Updating Target Network')
model_weights = self.model.get_weights()
self.mutex.acquire(1)
self.model_target.set_weights(model_weights)
self.mutex.release()
def Convert_State_To_Input(self, state):
if (self.statePreprocessType == "Tensor"):
# Create zero filled output value
outValue = np.zeros(shape=(self.numberofagent, self.gridsize,
self.gridsize))
# Convert list to numpy array
state = np.reshape(state, (1, state.shape[0]))
# Decompose states
states = np.split(state[0], self.numberofagent)
# Fill output tensor with agents position
for i in range(self.numberofagent):
row = int(states[i][0])
col = int(states[i][1])
outValue[i, row, col] = 1
if self.convolutionLayer == True:
return outValue
else:
return outValue.flatten()
elif (self.statePreprocessType == "Vector"):
return state
def Get_Greedy_Pair(self, state):
# Backward compability: Preprocess state input if needed.
if np.size(state) != self.size_of_input_units:
values = self.ForwardPass(self.Convert_State_To_Input(state))
else:
values = self.ForwardPass(state)
# Get the maximums
arg = values.argmax()
valmax = values.max()
return arg, valmax
def Get_Value(self, state, action):
values = self.ForwardPass(self.Convert_State_To_Input(state))
index = self.Get_Action_Index(action)
temp = values[index]
return temp
def ForwardPass(self, input):
# Form Input Values
if self.convolutionLayer == True:
input = np.reshape(
input, (1, input.shape[0], input.shape[1], input.shape[2]))
else:
input = np.reshape(input, (1, input.shape[0]))
self.mutex.acquire(1)
# Prediction of the model
with self.graph.as_default():
hypothesis = self.model_target.predict(input)
self.mutex.release()
values = np.asarray(hypothesis).reshape(self.output_unit)
return values
def Get_Action_Index(self, action):
sizeOfAction = action.shape[0]
temp = 0
for i in np.arange(sizeOfAction):
temp = temp + action[i] * (self.actionspaceforagent**
(sizeOfAction - i - 1))
return temp
def Set_Value(self, state, action, value):
# Preprocess State
state = self.Convert_State_To_Input(state)
# Update label
values = self.ForwardPass(state)
index = self.Get_Action_Index(action)
# Calculate error for Prioritized Experience Replay
error = abs(values[index] - value)
values[index] = value
# Append new sample to Memory of Experiences
# Don't worry about its size, since it is a queue
self.memory.add(error, (state, values))
# To be able to stop learner thread if there is no more experience
if self.experience_counter < 10: #self.experiencebuffersize:
self.experience_counter += 1
return self.trainingepochtotal
def Learn(self):
#if self.fresh_experience_counter == self.batchsize :
if self.memory.length(
) >= self.batchsize and self.experience_counter > 0:
self.trainingepochtotal += self.trainPass
#print('Training Epoch:', self.trainingepochtotal)
# Get Unique Samples from memory as much as batchsize
minibatch = self.memory.sample(self.batchsize)
batchSamplesX = []
batchSamplesY = []
for i in np.arange(len(minibatch)):
idx, (X, Y) = minibatch[i]
batchSamplesX.append(X)
batchSamplesY.append(Y)
with self.graph.as_default():
self.model.fit(np.array(batchSamplesX),
np.array(batchSamplesY),
epochs=self.trainPass,
batch_size=self.batchsize,
verbose=0)
if not self.trainingepochtotal % self.update_target_interval:
self.Update_target()
# To be able to stop learner thread if there is no more experience
self.experience_counter -= 1
else:
print("Sleeping Learner Thread")
time.sleep(1)
# Learner Thread Run Function
def Learner(self):
while self.flag_continue:
self.Learn()
print("Thread Learner stopped.")
def Reset_Batch(self):
# Reset the batch
if self.convolutionLayer == True:
self.batchSamplesX = np.array([], dtype=np.float).reshape(
0, self.numberofagent, self.gridsize, self.gridsize)
self.batchSamplesY = np.array([], dtype=np.float).reshape(
0, self.output_unit)
else:
self.batchSamplesX = np.array([], dtype=np.float).reshape(
0, self.size_of_input_units)
self.batchSamplesY = np.array([], dtype=np.float).reshape(
0, self.output_unit)
def Add_Experience(self, state, action, nextstate, reward, status):
# WORKING
arg_Qmax, Qmax = self.Get_Greedy_Pair(nextstate)
QValue = reward + self.Gamma * Qmax
self.Set_Value(state, action, QValue)
def Save_Model(self):
with self.graph.as_default():
if not os.path.exists("log/" + self.logfolder):
os.makedirs("log/" + self.logfolder)
self.model.save("log/" + self.logfolder + "/model_" +
self.modelId + ".h5")
self.model.save_weights("log/" + self.logfolder +
"/model_weight_" + self.modelId + ".h5")
print("###############################")
print("Model saved: " + "log/" + self.logfolder)
print("###############################")
def __del__(self):
self.Save_Model()
self.flag_continue = False
print('Representation object died.')
class stock_LSTM:
""" This class is intended to include strictly the methods used for creating and interacting with the model itself"""
''' All of the parameters passed to these methods must be normalized and shaped correctly'''
def __init__(self):
self.model = Sequential()
def build_model(self,
neurons=100,
input_steps=49,
dropout_rate=0.2,
loss="mse",
optimizer="adam"):
self.model.add(
LSTM(neurons, input_shape=(input_steps, 16),
return_sequences=True))
self.model.add(Dropout(dropout_rate))
self.model.add(LSTM(neurons, return_sequences=True))
self.model.add(Dropout(dropout_rate))
self.model.add(LSTM(neurons, return_sequences=False))
self.model.add(Dropout(dropout_rate))
self.model.add(Dense(1, activation="linear"))
self.model.compile(loss=loss,
optimizer=optimizer,
metrics=['accuracy'])
debug('[Model] Model Compiled')
return self.model
def train(self,
x,
y,
epochs=1,
batch_size=32,
save_dir=os.path.join(environment, "saved_models"),
save_name=None,
save=True):
print('[Model] Training Started')
print('[Model] %s epochs, %s batch size' % (epochs, batch_size))
if save_name == None:
save_fname = os.path.join(
save_dir, '%s-e%s.h5' %
(dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs)))
else:
save_fname = save_name
callbacks = [
EarlyStopping(monitor='val_accuracy', patience=2),
ModelCheckpoint(filepath=save_fname,
monitor='val_accuracy',
save_best_only=True)
]
self.model.fit(
x,
y,
epochs=epochs,
batch_size=batch_size,
callbacks=callbacks,
)
debug('[Model] Training Completed.')
if save:
self.model.save(save_fname)
debug('Model saved as %s' % save_fname)
def load_model(self, filepath):
debug('[Model] Loading model from file %s' % filepath)
self.model = load(filepath)
self.session = tf.compat.v1.get_default_session()
self.model._make_predict_function()
self.graph = tf.compat.v1.get_default_graph()
self.graph.finalize()
def predict_point_by_point(self, data):
# Predict each timestep given the last sequence of true data, in effect only predicting 1 step ahead each time
debug('[Model] Predicting Point-by-Point...')
predicted = self.model.predict_on_batch(data)
predicted = np.reshape(predicted, (predicted.size, ))
return predicted
class Jogador:
peakVal = 0.2
sigma = 0.001
numeroJogadasAFrente = 5
numeroDePossiveisComidasParaNaoConsiderarJogadaForcada = 3
pontosQuandoPerde = -2
pontosQuandoGanha = 1
pontosQuandoEmpata = 0
numeroDeLayers = 3
def __init__(self,
model=None,
valorDama=None,
listaSigmas=None,
geracao=0,
genealogia=[],
debug=False):
self.listaSigmas = []
listaWeights = []
self.currentPoints = 0
self.totalPoints = 0
self.numeroDeGeracoesVivo = 1
self.geracao = geracao
if (valorDama is None):
self.valorDama = 2.0
else:
self.valorDama = valorDama
if (model is None):
initializer = initializers.random_uniform(minval=(-1) *
Jogador.peakVal,
maxval=Jogador.peakVal)
self.model = Sequential()
self.model.add(
Dense(40,
input_dim=32,
kernel_initializer=initializer,
activation='tanh'))
# self.model.add (Dense (40, kernel_initializer=initializer, activation = 'tanh'))
self.model.add(
Dense(10, kernel_initializer=initializer, activation='tanh'))
self.model.add(
Dense(1, kernel_initializer=initializer, activation='tanh'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model._make_predict_function()
else:
self.model = model
self.model._make_predict_function()
if (listaSigmas is None):
for layerIndex in range(self.numeroDeLayers):
layer = self.model.get_layer(index=layerIndex)
layerWeights = layer.get_weights()
arrayWeights = np.zeros(
(layerWeights[0].shape[0],
layerWeights[0].shape[1])) + self.sigma
arrayBiases = np.zeros(layerWeights[1].shape[0]) + self.sigma
listaWeights.clear()
listaWeights.append(arrayWeights)
listaWeights.append(arrayBiases)
self.listaSigmas.append(copy.deepcopy(listaWeights))
else:
self.listaSigmas = listaSigmas
self.nomeJogador = "Jogador_" + str(uuid.uuid4()) + ".h5"
self.genealogia = copy.deepcopy(genealogia)
listaNomeJogador = []
listaNomeJogador.append(self.nomeJogador)
listaGeracaoJogador = []
listaGeracaoJogador.append(self.geracao)
listaGeral = []
listaGeral.append(listaNomeJogador)
listaGeral.append(listaGeracaoJogador)
self.genealogia.append(listaGeral)
self.debug = debug
def predict(self, tabuleiro):
if (tabuleiro.ndim == 1):
tabuleiro = np.array([tabuleiro])
return self.model.predict(tabuleiro)
def salvaModelo(self):
self.model.save(".\modelos\\" + self.nomeJogador)
file = open(".\pesosDamas\\" + self.nomeJogador, "w+")
file.write(str(self.valorDama))
file.close
file2 = open(".\genealogia\\" + self.nomeJogador, "w+")
file2.write(str(self.genealogia))
file2.close
def carregaModelo(self):
self.model = load_model(".\modelos\\" + self.nomeJogador)
self.model._make_predict_function()
def calculaScoreTabuleiro(self, tabuleiro, numeroDaJogada):
if (numeroDaJogada == self.numeroJogadasAFrente):
return 0.0
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
maxScore = -9999999999
numeroDaProximaJogada = numeroDaJogada
if (not jogadaForcada):
numeroDaProximaJogada += 1
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
score = (self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama)) +
self.calculaScoreTabuleiro(
tabuleiro, numeroDaProximaJogada)) / 2.0
if (score > maxScore and numeroDaJogada == 0):
maxScore = score
return maxScore
def selecionaMelhorJogada(self, tabuleiro, numeroDaJogada):
tabuleiroEscolhido = None
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
maxScore = -9999999999
numeroDaProximaJogada = numeroDaJogada
if (not jogadaForcada):
numeroDaProximaJogada += 1
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
score = (self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama)) +
self.calculaScoreTabuleiro(
tabuleiro, numeroDaProximaJogada)) / 2.0
if (score > maxScore and numeroDaJogada == 0):
# print ("SCORE MAIOR: " + str(score))
# tabuleiro.printaTabuleiro ()
maxScore = score
tabuleiroEscolhido = copy.deepcopy(tabuleiro)
return tabuleiroEscolhido
def calculaScoreTabuleiroMinMax(self, tabuleiro, numeroDaJogada,
jogadorJogando, alpha, beta):
if (numeroDaJogada >= self.numeroJogadasAFrente):
if (jogadorJogando):
tabuleiro.inverteVisaoTabuleiro()
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = -1.1
return score
else:
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
tabuleiro.inverteVisaoTabuleiro()
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = 1.1
return score
tabuleiro.inverteVisaoTabuleiro()
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
numeroDaProximaJogada = numeroDaJogada
if (not jogadaForcada):
numeroDaProximaJogada += 1
if (jogadorJogando):
best = -9999999999
else:
best = 9999999999
if (len(listaTabuleiros) == 0):
if (jogadorJogando):
return -1
else:
return 1
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
if (jogadorJogando):
best = max(
best,
self.calculaScoreTabuleiroMinMax(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), False,
copy.deepcopy(alpha), copy.deepcopy(beta)))
alpha = max(alpha, best)
if (beta <= alpha):
break
else:
best = min(
best,
self.calculaScoreTabuleiroMinMax(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), True,
copy.deepcopy(alpha), copy.deepcopy(beta)))
beta = min(beta, best)
if (beta <= alpha):
break
return best
def calculaScoreTabuleiroMinMax2(self, tabuleiro, numeroDaJogada,
jogadorJogando):
if (numeroDaJogada >= self.numeroJogadasAFrente):
if (jogadorJogando):
tabuleiro.inverteVisaoTabuleiro()
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = -1.1
return score
else:
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
tabuleiro.inverteVisaoTabuleiro()
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = 1.1
return score
tabuleiro.inverteVisaoTabuleiro()
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
numeroDaProximaJogada = numeroDaJogada
if (not jogadaForcada):
numeroDaProximaJogada += 1
if (jogadorJogando):
best = -1.1
else:
best = 1.1
if (len(listaTabuleiros) == 0):
if (jogadorJogando):
return -1
else:
return 1
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
if (jogadorJogando):
best = max(
best,
self.calculaScoreTabuleiroMinMax2(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), False))
else:
best = min(
best,
self.calculaScoreTabuleiroMinMax2(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), True))
return best
def calculaScoreTabuleiroMedia(self, tabuleiro, numeroDaJogada,
jogadorJogando):
if (numeroDaJogada >= self.numeroJogadasAFrente):
if (jogadorJogando):
tabuleiro.inverteVisaoTabuleiro()
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = -1.1
return score
else:
score = self.predict(
tabuleiro.converteTabuleiroParaArray(self.valorDama))
tabuleiro.inverteVisaoTabuleiro()
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
if (len(listaTabuleiros) == 0 or listaTabuleiros is None):
score = 1.1
return score
tabuleiro.inverteVisaoTabuleiro()
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
numeroDaProximaJogada = numeroDaJogada
numeroDaProximaJogada += 1
# if (not jogadaForcada):
# numeroDaProximaJogada += 1
if (len(listaTabuleiros) == 0):
if (jogadorJogando):
return -1
else:
return 1
soma = 0
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
if (jogadorJogando):
soma += self.calculaScoreTabuleiroMedia(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), False)
else:
soma += self.calculaScoreTabuleiroMedia(
copy.deepcopy(tabuleiro),
copy.deepcopy(numeroDaProximaJogada), True)
return soma / len(listaTabuleiros)
def selecionaMelhorJogadaMinMax(self, tabuleiro, numeroDaJogada):
tabuleiroEscolhido = None
jogadaForcada = False
gerenciadorDeTabuleiros = GerenciadorDeTabuleiros(tabuleiro)
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMultiplasComidas(
)
if (not listaTabuleiros or listaTabuleiros is None):
listaTabuleiros = gerenciadorDeTabuleiros.calculaPossibilidadesDeMovimentoNormal(
)
elif (len(listaTabuleiros) <
self.numeroDePossiveisComidasParaNaoConsiderarJogadaForcada):
jogadaForcada = True
alpha = -9999999999
beta = 9999999999
numeroDaProximaJogada = numeroDaJogada
if (not jogadaForcada):
numeroDaProximaJogada += 1
tabuleiroEscolhido = None
for tabuleiro in listaTabuleiros:
if (not tabuleiro is None):
# score = self.calculaScoreTabuleiroMinMax (copy.deepcopy(tabuleiro), numeroDaProximaJogada, False, alpha, beta)
score = self.calculaScoreTabuleiroMedia(
copy.deepcopy(tabuleiro), numeroDaProximaJogada, False)
if (score >= alpha and numeroDaJogada == 0):
alpha = score
tabuleiroEscolhido = copy.deepcopy(tabuleiro)
if (self.debug):
print("Tabuleiro Selecionado por score: " + str(score))
print("Tabuleiro:")
tabuleiroEscolhido.printaTabuleiro()
return tabuleiroEscolhido
def ganhaPartida(self):
self.currentPoints += self.pontosQuandoGanha
self.totalPoints += self.pontosQuandoGanha
def perdePartida(self):
self.currentPoints += self.pontosQuandoPerde
self.totalPoints += self.pontosQuandoPerde
def empataPartida(self):
self.currentPoints += self.pontosQuandoEmpata
self.totalPoints += self.pontosQuandoEmpata
def calculaQuantidadeDePesos(self):
quantidadeDePesos = 0
for layerIndex in range(self.numeroDeLayers):
layer = self.model.get_layer(index=layerIndex)
layerWeights = layer.get_weights()
quantidadeDePesos += layerWeights[0].shape[0] * layerWeights[
0].shape[1] + layerWeights[1].shape[0]
return quantidadeDePesos
def printaPesos(self):
for layerIndex in range(self.numeroDeLayers):
layer = self.model.get_layer(index=layerIndex)
layerWeights = layer.get_weights()
print(layerWeights)
def __del__(self):
del self.model
class Representation_Keras_MultiAgent_TensorInput(Representation):
def __init__(self,
gridsize=5,
actionspaceperagent=5,
numberofagent=2,
hidden_unit=[12, 12],
learning_rate=0.1,
batch_size=10,
trainpass=1,
experiencebuffer=100):
self.batchsize = batch_size
self.trainPass = trainpass
self.hidden_unit = hidden_unit
self.learningrate = learning_rate
self.size_of_input_units = gridsize * gridsize * numberofagent
self.gridsize = gridsize
self.memory = deque(maxlen=experiencebuffer)
self.fresh_experience_counter = 0
self.actionspaceforagent = actionspaceperagent
self.numberofagent = numberofagent
self.output_unit = actionspaceperagent**numberofagent
self.trainingepochtotal = 0
# create model
self.model = Sequential()
self.model.add(
Dense(self.hidden_unit[0],
activation='tanh',
input_dim=self.size_of_input_units))
for i in range(1, len(hidden_unit)):
self.model.add(Dense(self.hidden_unit[i], activation='tanh'))
self.model.add(Dense(self.output_unit, activation=LeakyReLU(0.3)))
# Compile model
self.model.compile(loss='mse', optimizer='sgd', metrics=['accuracy'])
self.model._make_predict_function()
#save the TensorFlow graph:
self.graph = tf.get_default_graph()
self.model.summary()
if os.path.isfile("modeltrained.h5"):
self.model.load_weights("modeltrained.h5")
print("###############################")
print("Existing model loaded.......")
print("###############################")
self.model.save_weights("modelinit.h5")
# Reset the batch
self.batchSamplesX = np.array([], dtype=np.float).reshape(
0, self.size_of_input_units)
self.batchSamplesY = np.array([], dtype=np.float).reshape(
0, self.output_unit)
def Convert_State_To_Input(self, state):
# Create zero filled output value
outValue = np.zeros(shape=(self.numberofagent, self.gridsize,
self.gridsize))
# Convert list to numpy array
state = np.reshape(state, (1, state.shape[0]))
# Decompose states
states = np.split(state[0], self.numberofagent)
# Fill output tensor with agents position
for i in range(self.numberofagent):
row = int(states[i][0])
col = int(states[i][1])
outValue[i, row, col] = 1
return outValue.flatten()
def Get_Greedy_Pair(self, state):
values = self.ForwardPass(self.Convert_State_To_Input(state))
# Get the maximums
arg = values.argmax()
valmax = values.max()
return arg, valmax
def Get_Value(self, state, action):
values = self.ForwardPass(self.Convert_State_To_Input(state))
index = self.Get_Action_Index(action)
temp = values[index]
return temp
def ForwardPass(self, input):
# Form Input Values
input = np.reshape(input, (1, input.shape[0]))
# Prediction of the model
with self.graph.as_default():
hypothesis = self.model.predict(input)
values = np.asarray(hypothesis).reshape(self.output_unit)
return values
def Set_Value(self, state, action, value):
#time_Convert_State_To_Input = time.time()
inputVal = self.Convert_State_To_Input(state)
#print("Convert_State_To_Input: %s seconds" % (time.time() - time_Convert_State_To_Input)) # 7.677078247070312e-05 seconds
#time_ForwardPass = time.time()
values = self.ForwardPass(inputVal)
#print("ForwardPass: %s seconds" % (time.time() - time_ForwardPass)) # 0.001142740249633789 seconds
#time_Get_Action_Index = time.time()
index = self.Get_Action_Index(action)
values[index] = value
#print("Get_Action_Index: %s seconds" % (time.time() - time_Get_Action_Index)) #0.12781143188476562 seconds
#time_Prepare_Fit = time.time()
# Rearrange the given input and output to make it appropriate for our NN
sampleX = inputVal
sampleY = values
#np.array([value],dtype=np.float)
# Fit the model
#state = np.reshape(state, (1, state.shape[0]))
#values = np.reshape(values, (1, values.shape[0]))
# Increase counter to ensure enough new samples are gathered
# self.fresh_experience_counter+=1
# Append new sample to Memory of Experiences
# Don't worry about its size, since it is a queue
self.memory.append((sampleX, sampleY))
#if self.fresh_experience_counter == self.batchsize :
if len(self.memory) >= self.batchsize:
self.trainingepochtotal += self.trainPass
#print('Training Epoch:', self.trainingepochtotal)
# Reset the counter
# self.fresh_experience_counter=0
# Get Unique Samples from memory as much as batchsize
minibatch = random.sample(list(self.memory), self.batchsize)
for i in np.arange(len(minibatch)):
X, Y = minibatch[i]
self.batchSamplesX = np.vstack((self.batchSamplesX, X))
self.batchSamplesY = np.vstack((self.batchSamplesY, Y))
#time_Fit = time.time()
with self.graph.as_default():
self.model.fit(self.batchSamplesX,
self.batchSamplesY,
epochs=self.trainPass,
batch_size=self.batchsize,
verbose=0)
#print("Get_Fit: %s seconds" % (time.time() - time_Fit)) #0.12662458419799805 seconds
# Reset the batch
self.batchSamplesX = np.array([], dtype=np.float).reshape(
0, self.size_of_input_units)
self.batchSamplesY = np.array([], dtype=np.float).reshape(
0, self.output_unit)
#print("Get_Prepare_Fit: %s seconds" % (time.time() - time_Prepare_Fit)) #0.12781143188476562 seconds
# # Increase counter to ensure enough new samples are gathered
# self.fresh_experience_counter+=1
#
# # Append new sample to Memory of Experiences
# # Don't worry about its size, since it is a queue
# self.memory.append((sampleX, sampleY))
#
# if self.fresh_experience_counter == self.batchsize :
#
# # Reset the counter
# self.fresh_experience_counter=0
#
# # Get Unique Samples from memory as much as batchsize
# minibatch = random.sample(list(self.memory), self.batchsize)
#
# for i in np.arange(len(minibatch)):
# X, Y = minibatch[i]
# self.batchSamplesX = np.vstack((self.batchSamplesX, X))
# self.batchSamplesY = np.vstack((self.batchSamplesY, Y))
#
# print('Training Batch... ')
#
# # Fit the model
# self.model.fit(self.batchSamplesX, self.batchSamplesY, epochs=self.trainPass, batch_size=1, verbose=0)
#
# # Reset the batch
# self.batchSamplesX = np.array([], dtype=np.float).reshape(0, self.size_of_input_units)
# self.batchSamplesY = np.array([], dtype=np.float).reshape(0, self.output_unit)
#TODO: Modify it for multiagent case
def Get_Action_Index(self, action):
#print("action:", action) #action: [1 4 4]
#print(type(action)) #< class 'numpy.ndarray'>
#print(action.shape) #(3,)
#
# if action.shape[0]==1 :
# temp = action[0]
#
# elif action.shape[0]==2 :
# temp = action[0] * self.actionspaceforagent + action[1]
#
# elif action.shape[0]==3 :
# temp = action[0] * (self.actionspaceforagent**2) \
# + action[1] * (self.actionspaceforagent**1) \
# + action[2] * (self.actionspaceforagent**0)
sizeOfAction = action.shape[0]
temp = 0
for i in np.arange(sizeOfAction):
temp = temp + action[i] * (self.actionspaceforagent**
(sizeOfAction - i - 1))
return temp
def Save_Model(self):
with self.graph.as_default():
self.model.save_weights("modelOutput.h5")
print("###############################")
print("Model saved.......")
print("###############################")
def Add_Experience(self, state, action, nextstate, reward, status):
raise NotImplementedError()
def __del__(self):
print('Representation object died.')
