def main():
global keysPressed
pickle_fname = "collectedData/dataIndex.p"
dataIndex = open_dataIndex(pickle_fname)
training_data_body = []
training_data_head = []
countDown(5)
# Setup for screenGrab
last_time = time.time()
W, H = 575, 525
# This beautiful solution comes from JHolta on:
# https://stackoverflow.com/questions/69645/take-a-screenshot-via-a-python-script-linux
# It can be improved to do C-based implementation, but it is basically real-time now.
dsp = display.Display()
root = dsp.screen().root
prevX, prevY = getMousePos(root)
while True:
#for k in keysPressed:
#print(k)
image = grabscreen(root, W, H)
image = cv2.resize(image, (299, 299))
output_body = keys_to_output(keysPressed)
output_head, prevX, prevY = mmove_to_output(root, prevX, prevY)
#print(output_body)
#print(output_head)
training_data_body.append([image, output_body])
training_data_head.append([image, output_head])
print('loop took {:0.3f} seconds'.format(time.time() - last_time))
last_time = time.time()
keysPressed = [
] # refresh it each time we loop to keep out past inputs
#cv2.imshow('window',image)
time.sleep(
0.01
) # Needs to be there for the async hook and this synced loop to keep up with each other
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
if len(training_data_body) % 500 == 0:
print(len(training_data_body))
dataIndex = save_npy_file("body", dataIndex, training_data_body,
pickle_fname, 0)
dataIndex = save_npy_file("head", dataIndex, training_data_head,
pickle_fname, 1)
# Restarts array for next batch
training_data_body = []
training_data_head = []
def main():
SaveData = False
global keysPressed
pickle_fname = "collectedData/dataIndex_both.p"
dataIndex = open_dataIndex(pickle_fname)
training_data = []
# Setup for screenGrab
last_time = time.time()
W, H = 575, 525
dsp = display.Display()
root = dsp.screen().root
countDown(5)
while True:
image = grabscreen(root, W, H)
image = cv2.resize(image, (299, 299))
output_body = b_keys_to_output(keysPressed)
output_head = h_keys_to_output(keysPressed)
training_data.append([image, output_body, output_head])
time.sleep(
0.01
) # Needs to be there for the async hook and this synced loop to keep up with each other
#print('loop took {:0.3f} seconds'.format(time.time()-last_time))
last_time = time.time()
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
if len(training_data) % 500 == 0:
if SaveData:
print(dataIndex)
dataIndex = save_npy_file("both", dataIndex, training_data,
pickle_fname)
# Restarts array for next batch
training_data = []
def main():
########################################################
# Initialize
########################################################
global keysPressed
dataIndex = 0
EpisodicMemCap = 100
dataIndex_episode = pickle.load(
open("trainingData/episodeData/dataIndex_episode.p", "rb"))
# Load model
WIDTH = HEIGHT = 224
FILENUM = pickle.load(
open("trainingData/Unbalanced_rgb_299/dataIndex_{}.p".format('both'),
"rb"))
#FILENUM_both = 458
model = get_Keras_model('both', WIDTH, HEIGHT, 8, "AdamReg", FILENUM)
# Setup for screenGrab
last_time = time.time()
W, H = 575, 525
dsp = display.Display()
screen = dsp.screen()
root = dsp.screen().root
countDown(5)
while True:
########################################################
#Reinforcement Loop
########################################################
isSolved = False
trainingData = []
while not isSolved:
"""
During the puzzle, this loop will play till it gets determined that
the puzzle has been solved.
"""
############################
# Get Image
############################
image = grabscreen(root, W, H)
image_rs = cv2.resize(image, (WIDTH, HEIGHT))
############################
# Make Predictions
############################
body_moves = [0, 0, 0, 0, 0]
head_moves = [0, 0, 0, 0, 0]
p_body, p_head = model.predict(
[image_rs.reshape(1, WIDTH, HEIGHT, 3)])
# This method ensures that each frame, the agent will pick the most likely option.
body_m_index = np.argmax(p_body[0])
head_m_index = np.argmax(p_head[0])
body_moves[body_m_index] = 1
head_moves[head_m_index] = 1
print(body_moves)
print(head_moves)
############################
# See if Supervisor overrides
############################
trainingData = SupervisorCheck(cv2.resize(image,
(299, 299)), body_moves,
head_moves, trainingData)
print('loop took {:0.3f} seconds'.format(time.time() - last_time))
last_time = time.time()
############################
# Store episodic memory to file.
############################
if len(trainingData) == 100:
# Sets of 100 so I don't need to preprocess.
print(dataIndex)
shuffle(trainingData) # Just randomize it now.
dataIndex += 1
#Write to new datafile. Formatted to fit with current dataGenerator code.
np.save(
"trainingData/episodeData/episodeData/data_{}".format(
dataIndex), trainingData)
# Restarts array for next batch
trainingData = []
if 'm' in keysPressed or 'M' in keysPressed:
# My manual way to break the loop
isSolved = True
"""
Needs to be there for the async hook and this synced loop
to keep up with each other
"""
time.sleep(0.01)
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
print("Number of frames in Episodic Memory: {}".format(dataIndex))
#Stop the agent
move_body([0, 0, 0, 0, 1])
move_head([0, 0, 0, 0, 1])
if dataIndex > EpisodicMemCap:
########################################################
# Retrain the Agent's Policy
########################################################
for i, layer in enumerate(model.layers):
print(i, layer.name)
# Only train the last dense layers that I personally added to VGG16.
Layer_End = 19
for layer in model.layers[:Layer_End]:
layer.trainable = False
for layer in model.layers[Layer_End:]:
layer.trainable = True
# Training Setup
EPOCHS = 4
DTYPE = DATA_TYPE = 'episodeData'
TrainLen = dataIndex - 10
Indicies = np.array(range(1, dataIndex + 1))
shuffle(Indicies)
TrainIndex = Indicies[:TrainLen]
ValidIndex = Indicies[TrainLen:]
params = {
'WIDTH': WIDTH,
'HEIGHT': HEIGHT,
'DTYPE': DTYPE,
'DATA_TYPE': DATA_TYPE,
'isConcat': True,
'batch_size': 1,
'shuffle': True
}
training_generator = DataGenerator(Indicies, **params)
validation_generator = DataGenerator(ValidIndex, **params)
# Defining my callbacks:
filepath = "models/SupervisedReinforcement/best_weights.h5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_dense_5_acc',
verbose=1,
save_best_only=True,
mode='max')
callbacks_list = [checkpoint]
# compile the model (should be done *after* setting layers to non-trainable)
model.compile(optimizer=SGD(lr=1e-4, momentum=0.9),
loss='categorical_crossentropy',
metrics=['acc'])
#model.compile(optimizer=Adam(lr=0.0001), loss='categorical_crossentropy', metrics=['acc'])
# Train the model on the new data for a few epochs
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
callbacks=callbacks_list,
use_multiprocessing=True,
workers=6,
epochs=EPOCHS,
steps_per_epoch=dataIndex)
#Reload the best weights from that update session
model.load_weights(
"models/SupervisedReinforcement/best_weights.h5")
# Save data rather than delete because it is like 10k data samples
dataIndex_episode += 1
shutil.move(
"trainingData/episodeData/episodeData",
"trainingData/episodeData/episodeDataArchived/E{}".format(
dataIndex_episode))
subprocess.call(['mkdir', 'trainingData/episodeData/episodeData'])
pickle.dump(
dataIndex_episode,
open("trainingData/episodeData/dataIndex_episode.p", "wb"))
dataIndex = 0
else:
# wait till I tell it to start testing again.
testStart = False
while not testStart:
if 'n' in keysPressed or 'N' in keysPressed:
testStart = True
def main():
SaveData = True
global keysPressed
pickle_fname = "collectedData/dataIndex_head.p"
dataIndex = open_dataIndex(pickle_fname)
training_data= []
#This chunk could probably be abstracted out?
WIDTH = HEIGHT = 224
LR = 1e-4
EPOCHS_1 = 4
DTYPE = 'body'
OPTIMIZER = 'Adam'
DATA_TYPE = "Unbalanced_rgb_299"
ARCH = "VGG16"
#FILENUM = pickle.load(open("trainingData/Unbalanced_rgb_299/dataIndex_{}.p".format(DTYPE), "rb"))
FILENUM = 3335
MODEL_NAME = 'pytalos_{}_{}_{}_{}_files_{}_epocs_{}_{}.h5'.format(DTYPE, ARCH, OPTIMIZER, FILENUM, EPOCHS_1, DATA_TYPE,LR)
model_path = "models/{}/{}".format(DTYPE,MODEL_NAME)
print(model_path)
model = load_model(model_path)
model.load_weights("models/{}/best_weights_{}".format(DTYPE,MODEL_NAME))
# Setup for screenGrab
last_time = time.time()
W,H = 575,525
dsp = display.Display()
root = dsp.screen().root
countDown(5)
while True:
#print(keysPressed)
image = grabscreen(root, W,H)
image = cv2.resize(image,(299,299))
image_predict = cv2.resize(image,(WIDTH,HEIGHT))
# Move the body.
prediction = model.predict([image_predict.reshape(1,WIDTH,HEIGHT,3)])[0]
moves = list(np.around(prediction))
move_body(moves)
# Classify the movement for the head.
output_head = h_keys_to_output(keysPressed)
training_data.append([image, output_head])
#cv2.imshow('window',image)
time.sleep(0.01) # Needs to be there for the async hook and this synced loop to keep up with each other
#print('loop took {:0.3f} seconds'.format(time.time()-last_time))
last_time = time.time()
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
if len(training_data) % 500 == 0:
if SaveData:
print(dataIndex)
dataIndex = save_npy_file("head", dataIndex, training_data, pickle_fname)
# Restarts array for next batch
training_data = []