def main():
parser = argparse.ArgumentParser()
parser.add_argument('--board-size', type=int, default=19)
parser.add_argument('--network', default='large')
parser.add_argument('--hidden-size', type=int, default=512)
parser.add_argument('--output_file', '-o', type=str, default='./agents/q_agent_0.h5')
args = parser.parse_args()
encoder = encoders.get_encoder_by_name('simple', args.board_size)
board_input = Input(shape=encoder.shape(), name='board_input')
action_input = Input(shape=(encoder.num_points(),), name='action_input')
processed_board = board_input
network = getattr(dlgo.networks, args.network)
for layer in network.layers(encoder.shape()):
processed_board = layer(processed_board)
board_plus_action = concatenate([action_input, processed_board])
hidden_layer = Dense(args.hidden_size, activation='relu')(board_plus_action)
value_output = Dense(1, activation='sigmoid')(hidden_layer)
model = Model(inputs=[board_input, action_input], outputs=value_output)
new_agent = rl.QAgent(model, encoder)
with h5py.File(args.output_file, 'w') as outf:
new_agent.serialize(outf)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--board-size', type=int, default=19)
parser.add_argument('--output-file', required=True)
args = parser.parse_args()
board_size = args.board_size
output_file = args.output_file
encoder = encoders.get_encoder_by_name('simple', board_size)
board_input = Input(shape=encoder.shape(), name='board_input')
action_input = Input(shape=(encoder.num_points(), ), name='action_input')
conv1a = ZeroPadding2D((2, 2))(board_input)
conv1b = Conv2D(64, (5, 5), activation='relu')(conv1a)
conv2a = ZeroPadding2D((1, 1))(conv1b)
conv2b = Conv2D(64, (3, 3), activation='relu')(conv2a)
flat = Flatten()(conv2b)
processed_board = Dense(512)(flat)
board_and_action = concatenate([action_input, processed_board])
hidden_layer = Dense(256, activation='relu')(board_and_action)
value_output = Dense(1, activation='tanh')(hidden_layer)
model = Model(inputs=[board_input, action_input], outputs=value_output)
new_agent = rl.QAgent(model, encoder)
with h5py.File(output_file, 'w') as outf:
new_agent.serialize(outf)
def main():
pth = "//home//nail//Code_Go//checkpoints//"
pth_experience = '//home//nail//Experience//'
# board_size =19
# hidden_size =512 # Можно экспериментировать. В книге было 256
learning_agent = input('Агент для обучения "ценность действия": ')
num_games = int(input('Количество игр для формирования учебных данных = '))
try:
chunk = int(input('Порция игр в одном файле для обучения = '))
except:
chunk = 100
delta_games = int(input('Приращение количества игр = '))
learning_agent = pth+learning_agent+'.h5' # Это начальный агент либо первый либо для продолжения обучения
output_file = pth+'new_q_agent.h5' # Это будет уже агент обновляемый с лучшими результатами игр
current_agent = pth + 'current_agent.h5' # Текущий обучаемый агент
try:
lr = float(input('Скорость обучения lr = '))
except:
lr = 0.01
temp_decay = 0.98
min_temp = 0.001
try:
temperature = float(input('Temperature = '))
except:
temperature = min_temp
try:
batch_size = int(input("batch_size = "))
except:
batch_size = 512
try:
epochs = int(input('Epochs = '))
except:
epochs = 1
log_file = input('Журнал обработки: ')
log_file = pth_experience + log_file+'.txt'
logf = open(log_file, 'a')
logf.write('----------------------\n')
logf.write('Начало обучения агента %s в %s\n' % (
learning_agent, datetime.datetime.now()))
# Строится модель для обучения ценность действия
# Два входа, один выход.
# Компиляция модели если еще нет модели для ценности действия.
# Иначе загружаем уже существующую модель.
if ('q_agent' in learning_agent and os.path.isfile(learning_agent)) == False:
exit(10)
pattern = input('Паттерн для выборки файлов для обучения: ')
if len(pattern) == 0:
pattern = "exp*.h5"
total_work = 0 # Счетчик "прогонов" обучения.
while True: # Можно всегда прервать обучение и потом продолжть снова.
l_agent = load_agent(learning_agent)
model = l_agent.model
encoder = l_agent.encoder
num_moves = encoder.num_points()
logf.write('Прогон = %d\n' % total_work)
print(50 * '=')
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
# ==============================================================
# Формируем список файлов с экспериментальными игровыми данными
for entry in lst_files:
if fnmatch.fnmatch(entry, pattern):
experience.append(entry)
# Получили список файлов игр для обучения
# Сортировка для удобства файлов.
if len(experience) > 0:
experience.sort()
else:
print(' Нет файлов в папке для обучения!!!!')
exit(2)
n = []
experience.sort()
len_experience = len(experience) # Количество файлов для обучения
exp_buffers = []
states = []
for exp_filename in experience:
print('Файл с играми для обучения: %s...' % exp_filename)
exp_buffer = rl.load_experience(h5py.File(exp_filename, "r"))
exp_buffers.append(exp_buffer)
n.append(exp_buffer.states.shape[0])
states.extend(exp_buffer.states)
gc.collect()
n_all = sum(n) # Общее количество состояний игр во всех файлах
print(' Количество состояний доски во всех играх = ',n_all)
del exp_buffer
gc.collect()
# Заполняем данными для обучения из считанного буфера с играми скомпилированную модель.
y = np.zeros((n_all,))
actions = np.zeros((n_all, num_moves))
k = 0
for j in range(len_experience):
for i in range(n[j]):
action = exp_buffers[j].actions[i]
reward = exp_buffers[j].rewards[i]
actions[k+i][action] = 1
y[k+i] = reward
k +=n[j]
del exp_buffers
gc.collect()
# Обучение модели
model.fit(
[states, actions], y,
batch_size=batch_size,
verbose=1,
epochs=epochs)
# Прошлись по всем файлам
del states
del actions
del y
gc.collect()
#---------------------------------------------------------------------------
# Сохранение обученного агента нужно для оценки улучшения старого агента
# Если агент в игре будет лучше то он сохранится в out_file и новый обучаемый агент
# будет загружаться из обновленного с новыми игровыми данными проведенными этим
# обновленным агентом. Если нет, старый агент без изменений, только добавить
# дополнительное количество выполненных игр обучаемым агентом к прежним.
new_agent = rl.QAgent(model, encoder)
with h5py.File(current_agent, 'w') as outf: # Сохраняем агента как текущего
new_agent.serialize(outf)
print('\n Оцениваем нового агента с "старым" агентом\n')
wins = eval(current_agent, learning_agent, num_games=200)
print('Выиграно %d / %s игр (%.3f)' % (
wins, str(200), float(wins) / 200))
logf.write('Выиграно %d / %s игр (%.3f)\n' % (
wins, str(200), float(wins) / float(200)))
bt = binom_test(wins, 200, 0.5)*100
print('Бином тест = ', bt , '%')
logf.write('Бином тест = %f\n' % bt)
if bt <= 5 and wins > 115:
print('Обновление агента!!!!!')
# Сохраняем обученного агента
new_agent = rl.QAgent(model, encoder)
with h5py.File(output_file, 'w') as outf:
new_agent.serialize(outf)
logf.write('Выполнено обновление агента после успешного обучения %d время %s\n' % (total_work,
datetime.datetime.now()))
logf.write('Новый агент : %s\n' % output_file)
# Очистка каталога с данными игр "старого" агента
pth_exp_save = pth_experience+'Exp_Save'
os.chdir(pth_exp_save)
lst_files = os.listdir(pth_exp_save)
for entry in lst_files:
os.remove(entry)
# Сохраняем игровые данные в каталоге сохранения
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
for entry in lst_files:
if fnmatch.fnmatch(entry, 'exp*'):
experience.append(entry)
for exp_filename in experience:
shutil.move(exp_filename, pth_experience+'Exp_Save//'+exp_filename)
# Формируем список файлов с экспериментальными игровыми данными
temperature = max(min_temp, temp_decay * temperature)
exp_filename = 'exp'+str(total_work)+'_'
do_self_play(19, output_file, output_file, num_games=num_games,
temperature=temperature, experience_filename=exp_filename, chunk=chunk)
learning_agent = output_file # Теперь на следующей шаге обучаемым станет обновленный агент
logf.write('Новая "температура" = %f\n' % temperature)
else:
# print('Агента не меняем, Игровые данные увеличивам \n')
if num_games < 40000:
# Добавим порцию игр
#learning_agent оставляем без изменений. Новый обученный агент не лучше старого.
# Добавим порцию игр для дополнительного обучения.
exp_filename = 'exp' + str(total_work) + '_'
do_self_play(19, learning_agent, learning_agent,
num_games=delta_games, # Добавим новые файлы к уже существующим новые файлы.
temperature=temperature, experience_filename=exp_filename, chunk=chunk)
total_work += 1
print('Количество выполненных прогонов = ', total_work)
logf.write('Выполнен прогон %d время at %s\n' % (total_work,
datetime.datetime.now()))
logf.flush()
if total_work > 1000:
break
def main():
pth = "//media//nail//SSD_Disk//Models//"
pth_experience = '//media//nail//SSD_Disk//Experience//'
pth_experience_save = '//home//nail//Experience_Save//'
# board_size =19
learning_agent = input('Агент для обучения "ценность действия": ')
num_games = int(input('Количество игр для формирования учебных данных = '))
try:
chunk = int(input('Порция игр в одном файле для обучения = '))
except:
chunk = 100
try:
delta_games = float(input('Приращение количества игр(%) = ')) / 100
except:
delta_games = 0.4
learning_agent = pth + learning_agent + '.h5' # Это начальный агент либо первый либо для продолжения обучения
output_file = pth + 'new_q_agent.h5' # Это будет уже агент обновляемый с лучшими результатами игр
current_agent = pth + 'current_agent.h5' # Текущий обучаемый агент
try:
lr_begin = float(input('Скорость обучения lr = '))
except:
lr_begin = 0.01
lr = lr_begin
temp_decay = 0.98
min_temp = 0.0001
cnt_eval = 400
win_eval = 262
try:
temperature = float(input('Temperature = '))
except:
temperature = min_temp
try:
batch_size = int(input("batch_size = "))
except:
batch_size = 512
try:
epochs = int(input('Epochs = '))
except:
epochs = 1
log_file = input('Журнал обработки: ')
log_file = pth_experience + log_file + '.txt'
logf = open(log_file, 'a')
logf.write('----------------------\n')
logf.write('Начало обучения агента %s в %s\n' %
(learning_agent, datetime.datetime.now()))
# Строится модель для обучения ценность действия
# Два входа, один выход.
# Компиляция модели если еще нет модели для ценности действия.
# Иначе загружаем уже существующую модель.
if ('q_agent' in learning_agent
and os.path.isfile(learning_agent)) == False:
exit(10)
pattern = input('Паттерн для выборки файлов для обучения: ')
if len(pattern) == 0:
pattern = "exp*.h5"
total_work = 0 # Счетчик "прогонов" обучения.
while True: # Можно всегда прервать обучение и потом продолжть снова.
l_agent = load_agent(learning_agent)
model = l_agent.model
encoder = l_agent.encoder
num_moves = encoder.num_points()
logf.write('Прогон = %d\n' % total_work)
print(50 * '=')
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
# ==============================================================
# Формируем список файлов с экспериментальными игровыми данными
for entry in lst_files:
if fnmatch.fnmatch(entry, pattern):
experience.append(entry)
# Получили список файлов игр для обучения
# Сортировка для удобства файлов.
if len(experience) > 0:
experience.sort()
else:
print(' Нет файлов в папке для обучения!!!!')
exit(2)
experience.sort()
opt = sgd(learning_rate=lr)
model.compile(
loss='mse',
optimizer=opt) # Позволяет управлять скоростью сходимости
# Обучение модели fit_generator
model.fit_generator(
generator=generator_q(experience=experience,
num_moves=num_moves,
batch_size=batch_size),
steps_per_epoch=get_num_samples(experience=experience,
num_moves=num_moves,
batch_size=batch_size) /
batch_size,
verbose=1,
epochs=epochs)
# Прошлись по всем файлам
#---------------------------------------------------------------------------
# Сохранение обученного агента нужно для оценки улучшения старого агента
# Если агент в игре будет лучше то он сохранится в out_file и новый обучаемый агент
# будет загружаться из обновленного с новыми игровыми данными проведенными этим
# обновленным агентом. Если нет, старый агент без изменений, только добавить
# дополнительное количество выполненных игр обучаемым агентом к прежним и
# уменьшить скорость обучения learnig rate lr.
new_agent = rl.QAgent(model, encoder)
with h5py.File(current_agent,
'w') as outf: # Сохраняем агента как текущего
new_agent.serialize(outf)
print('\n Оцениваем нового агента с "старым" агентом\n')
wins = eval(current_agent, learning_agent, num_games=cnt_eval)
print('Выиграно %d / %s игр (%.3f)' %
(wins, str(cnt_eval), float(wins) / cnt_eval))
logf.write('Выиграно %d / %s игр (%.3f)\n' %
(wins, str(200), float(wins) / float(cnt_eval)))
bt = binom_test(wins, cnt_eval, 0.5) * 100
print('Бином тест = ', bt, '%')
logf.write('Бином тест = %f\n' % bt)
if bt <= 5 and wins > win_eval:
print('Обновление агента!!!!!')
# Сохраняем обученного агента
new_agent = rl.QAgent(model, encoder)
with h5py.File(output_file, 'w') as outf:
new_agent.serialize(outf)
logf.write(
'Выполнено обновление агента после успешного обучения %d время %s\n'
% (total_work, datetime.datetime.now()))
logf.write('Новый агент : %s\n' % output_file)
# Очистка каталога с данными игр "старого" агента
os.chdir(pth_experience_save)
lst_files = os.listdir(pth_experience_save)
for entry in lst_files:
os.remove(entry)
# Сохраняем игровые данные в каталоге сохранения
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
for entry in lst_files:
if fnmatch.fnmatch(entry, 'exp*'):
experience.append(entry)
for exp_filename in experience:
shutil.move(exp_filename, pth_experience_save + exp_filename)
# Формируем список файлов с экспериментальными игровыми данными
temperature = max(min_temp, temp_decay * temperature)
exp_filename = 'exp' + str(total_work) + '_'
# Опытным путем установлено, чтобы улучшить игру, усилить бота, надо увеличить количество игр
# так как только что обновленный агент на том же количестве игр не улучшится.
add_games = int(num_games * delta_games)
num_games = num_games + add_games
do_self_play(19,
output_file,
output_file,
num_games=num_games,
temperature=temperature,
experience_filename=exp_filename,
chunk=chunk)
learning_agent = output_file # Теперь на следующей шаге обучаемым станет обновленный агент
logf.write('Новая "температура" = %f\n' % temperature)
# восстановим скорость обучения, так как данные новые от нового агента
lr = lr_begin
else:
# print('Агента не меняем, Игровые данные увеличивам \n')
if num_games <= 20000:
# Добавим порцию игр
#learning_agent оставляем без изменений. Новый обученный агент не лучше старого.
# Добавим порцию игр для дополнительного обучения.
print(' Количестов игр на текущий момент = ', num_games)
add_games = int(num_games * delta_games)
if add_games > 0:
print(
' Добавили дополнительное количество игр для обучения = ',
add_games)
exp_filename = 'exp' + str(total_work) + '_'
do_self_play(
19,
learning_agent,
learning_agent,
num_games=
add_games, # Добавим новые файлы к уже существующим файлам.
temperature=temperature,
experience_filename=exp_filename,
chunk=chunk)
else:
print('Обработано предельно допустимое количество игр = ',
num_games)
break
lr = lr * 0.95 # Уменьшим скорость обучения.
print('Скорость обучения = ', lr)
total_work += 1
print('Количество выполненных прогонов = ', total_work)
logf.write('Выполнен прогон %d время at %s\n' %
(total_work, datetime.datetime.now()))
logf.flush()
if total_work > 1000:
break
def main():
board_size = 19
hidden_size = 1024
workdir = '//media//nail//SSD_Disk//Models//'
output_file = workdir + 'q_agent.h5'
lr = 0.01
batch_size = 512
pth = "//media//nail//SSD_Disk//Models//"
pth_experience = '//media//nail//SSD_Disk//Experience//'
experience_filename = pth_experience+'exp'
only_form_games = input('Только сформировать новые игровые данные с существующей моделью?(Y/N)').lower()
# "Заполнение" данными модели обучения из игр
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
pattern = input('Паттерн для выборки файлов для обучения: ')
if len(pattern) == 0:
pattern = "exp*.h5"
if only_form_games != 'y':
# ==============================================================
# Формируем список файлов с экспериментальными игровыми данными
new_form_games = input('Формировать новые игровые данные с созаданной моделью?(Y/N) ').lower()
count_exp = int(input('Сколько взять файлов для первичного обучения ? '))
len_lst_files = len(lst_files)
if count_exp<= len_lst_files:
for entry in lst_files[:count_exp]:
if fnmatch.fnmatch(entry, pattern):
experience.append(entry)
else:
for entry in lst_files:
if fnmatch.fnmatch(entry, pattern):
experience.append(entry)
# Получили список файлов игр для обучения
# Сортировка для удобства файлов.
if len(experience) > 0:
experience.sort()
else:
print(' Нет файлов в папке для обучения!!!!')
exit(2)
encoder = encoders.get_encoder_by_name('simple', board_size)
board_input = Input(shape=encoder.shape(), name='board_input')
action_input = Input(shape=(encoder.num_points(),), name='action_input')
# =============================================================
# Сеть такая же частично как large оригинальня авторов книги
# =============================================================
conv_0a = Conv2D(64, (7, 7), padding='same', activation='relu')(board_input)
# BatchNormalization()
conv_1a = Conv2D(64, (5, 5), padding='same', activation='relu')(conv_0a)
#BatchNormalization()
conv_2a = Conv2D(48, (5, 5), padding='same', activation='relu')(conv_1a)
#BatchNormalization()
conv_3a = Conv2D(48, (5, 5), padding='same', activation='relu')(conv_2a)
#BatchNormalization()
conv_4a = Conv2D(32, (5, 5), padding='same',activation='relu')(conv_3a)
#BatchNormalization()
flat = Flatten()(conv_4a)
processed_board = Dense(1024)(flat)
board_plus_action = concatenate([action_input, processed_board])
hidden_layer = Dense(hidden_size, activation='relu')(board_plus_action)
value_output = Dense(1, activation='sigmoid')(hidden_layer)
model = Model(inputs=[board_input, action_input], outputs=value_output)
opt = SGD(lr=lr)
model.compile(loss='mse', optimizer=opt)
# Обучение модели fit_generator
model.fit_generator(
generator=generator_q(experience=experience, num_moves=361, batch_size=batch_size),
steps_per_epoch=get_num_samples(experience=experience, num_moves=361, batch_size=batch_size) / batch_size,
verbose=1,
epochs=1,
initial_epoch=0)
# Прошлись по всем файлам
new_agent = rl.QAgent(model, encoder)
with h5py.File(output_file, 'w') as outf:
new_agent.serialize(outf)
if new_form_games == 'y':
# Формируем список файлов с экспериментальными игровыми данными c новым впервые обученным агентом с двумя входами.
num_games = int(input('Количество игр для генерации = '))
chunk = int(input('Количество игр в одном файле-порции = '))
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
for entry in lst_files:
#if fnmatch.fnmatch(entry, 'exp*'): журналы тоже в папку сохранения, чистка всего.
if os.path.isfile(entry) == True:
experience.append(entry)
for filename in experience:
shutil.move(filename, pth_experience + 'Exp_Save//' + filename)
do_self_play(19,output_file,output_file,num_games=num_games,temperature=0,
experience_filename=experience_filename,chunk=chunk)
else:
model_file = input('Файл с существующей моделью = ')
num_games = int(input('Количество игр для генерации = '))
chunk = int(input('Количество игр в одном файле-порции = '))
model_file = workdir + model_file + '.h5'
do_self_play(19, model_file, model_file, num_games=num_games, temperature=0,
experience_filename=experience_filename, chunk=chunk)
def main():
pth = "//home//nail//Code_Go//checkpoints//"
pth_experience = '//home//nail//Experience//'
board_size = 19
network = 'small'
hidden_size = 512
learning_agent = input('Агент для обучения "ценность действия": ')
num_games = int(input('Количество игр для формирования учебных данных = '))
delta_games = int(input('Приращение количества игр = '))
learning_agent = pth + learning_agent + '.h5' # Это агент либо от политики градиентов(глава 10),либо из главы 7"
output_file = pth + 'new_value_model.h5' # Это будет уже агент с двумя входами для ценности действия
current_agent = pth + 'current_model.h5' # Текущий обучаемый агент
lr = 0.0001
temp_decay = 0.98
min_temp = 0.00001
try:
temperature = float(input('Temperature = '))
except:
temperature = min_temp
try:
batch_size = int(input("batch_size = "))
except:
batch_size = 512
try:
epochs = int(input('Epochs = '))
except:
epochs = 1
log_file = input('Журнал обработки: ')
log_file = pth_experience + log_file + '.txt'
logf = open(log_file, 'a')
logf.write('----------------------\n')
logf.write('Начало обучения агента %s в %s\n' %
(learning_agent, datetime.datetime.now()))
# Строится модель для обучения ценность действия
# Два входа, один выход.
# Компиляция модели если еще нет модели для ценности действия.
# Иначе загружаем уже существующую модель.
if 'value_model' in learning_agent and os.path.isfile(learning_agent):
New_QAgent = False # Модель уже есть, надо продолжить обучение
encoder = '' # Чтобы не было предупреждений о возможной ошибке в коде ниже.
model = ''
else:
# Еще только надо создать модель для обучения
# Нет модели с двумя входами.
New_QAgent = True
encoder = encoders.get_encoder_by_name('simple', board_size)
board_input = Input(shape=encoder.shape(), name='board_input')
action_input = Input(shape=(encoder.num_points(), ),
name='action_input')
processed_board = board_input
network = getattr(dlgo.networks, network)
for layer in network.layers(encoder.shape()):
processed_board = layer(processed_board)
board_plus_action = concatenate([action_input, processed_board])
hidden_layer = Dense(hidden_size, activation='relu')(board_plus_action)
value_output = Dense(1, activation='sigmoid')(hidden_layer)
model = Model(inputs=[board_input, action_input], outputs=value_output)
opt = SGD(lr=lr)
model.compile(loss='mse', optimizer=opt)
# "Заполнение" данными модели обучения из игр
experience = []
os.chdir(pth_experience)
lst_files = os.listdir(pth_experience)
pattern = input('Паттерн для выборки файлов для обучения: ')
if len(pattern) == 0:
pattern = "exp*.h5"
#==============================================================
# Формируем список файлов с экспериментальными игровыми данными
for entry in lst_files:
if fnmatch.fnmatch(entry, pattern):
experience.append(entry)
# Получили список файлов игр для обучения
exp_filename = ''
if len(experience) > 0:
experience.sort()
exp_filename = experience[0] # Нужен только один файл
else:
print(' Нет файлов в папке для обучения!!!!')
exit(2)
#==============================================================
# callback_list = [ModelCheckpoint(pth, monitor='val_accuracy',
# save_best_only=True)]
total_work = 0 # Счетчик "прогонов" обучения.
exp_buffer = 'empty' # Буфер с игровыми данными
while True: # Можно всегда прервать обучение и потом продолжть снова.
if New_QAgent == False:
q_agent = load_agent(
learning_agent) # Текущая обучаемая модель cуществует
model = q_agent.model # загружаем модель
encoder = q_agent.encoder
#temperature = q_agent.temperature
logf.write('Прогон = %d\n' % total_work)
print(50 * '=')
print('Файл с играми для обучения: %s...' % exp_filename)
print(50 * '=')
if exp_buffer == 'empty':
exp_buffer = rl.load_experience(h5py.File(exp_filename, "r"))
# Заполняем данными для обучения из считанного буфера с играми скомпилированную модель.
n = exp_buffer.states.shape[0]
num_moves = encoder.num_points()
y = np.zeros((n, ))
actions = np.zeros((n, num_moves))
for i in range(n):
action = exp_buffer.actions[i]
reward = exp_buffer.rewards[i]
actions[i][action] = 1
y[i] = 1 if reward > 0 else -1 # было 0
# Обучение модели
model.fit([exp_buffer.states, actions],
y,
batch_size=batch_size,
epochs=epochs)
if total_work == 0: # Нового обученного агента для сравнения еще нет.
print('Обновление агента!!!!! Это первый обновленный агент.')
logf.write('Первое начальное обновление обученного агента\n')
# Сохраняем обученного агента
#output_file = output_file + '_' + str(total_work) + '.h5'
new_agent = rl.QAgent(model, encoder)
with h5py.File(current_agent, 'w') as outf:
new_agent.serialize(outf)
# os.chdir(pth_experience)
#
# lst_files = os.listdir(pth_experience)
# next_filename = 'exp_q_' + str(total_work) + '.h5'
# for entry in lst_files:
# if fnmatch.fnmatch(entry, "exp*"):
# shutil.move(exp_filename, pth_experience + 'Exp_Save//' + next_filename)
# #os.remove('//home//nail//Experience//'+entry) # Очистка каталога с данными игр "старого" агента
# # Формируем новые игровые данные с новым агентом.
# exp_filename = pth_experience+next_filename
# do_self_play(19, output_file, output_file, num_games=num_games,
# temperature=temperature, experience_filename=exp_filename)
# total_work += 1
if New_QAgent == True: # Не было еще агента с двумя входами.
total_work += 1
New_QAgent = False # Теперь есть сохраненная модельс двумя входами.
learning_agent = current_agent # Обучать будем нового созданного с двумя входами.
new_agent = rl.QAgent(model, encoder)
with h5py.File(current_agent,
'w') as outf: # Сохраняем агента как текущего
new_agent.serialize(outf)
continue # Сравнивать пока не с чем. Старые игровые данные оставляем
new_agent = rl.QAgent(model, encoder)
with h5py.File(current_agent,
'w') as outf: # Сохраняем агента как текущего
new_agent.serialize(outf)
# Сравниваем результат игры нового текущего агента с "старым" агентом.
wins = eval(current_agent, learning_agent, num_games=num_games)
print('Выиграно %d / %s игр (%.3f)' %
(wins, str(num_games), float(wins) / float(num_games)))
logf.write('Выиграно %d / %s игр (%.3f)\n' %
(wins, str(num_games), float(wins) / float(num_games)))
bt = binom_test(wins, num_games, 0.5) * 100
print('Бином тест = ', bt, '%')
logf.write('Бином тест = %f\n' % bt)
if bt <= 5 and wins > num_games / 2 + num_games / 10: # Означает не меньше чем 95% за то что новый бот играет лучше предыдущего
print('Обновление агента!!!!!')
# Сохраняем обученного агента
new_agent = rl.QAgent(model, encoder)
with h5py.File(output_file, 'w') as outf:
new_agent.serialize(outf)
logf.write(
'Выполнено обновление агента после успешного обучения %d время %s\n'
% (total_work, datetime.datetime.now()))
logf.write('Новый агент : %s\n' % output_file)
#os.remove('//home//nail//Experience//*') # Очистка каталога с данными игр "старого" агента
next_filename = 'exp_q_' + str(total_work) + '.h5'
shutil.move(exp_filename,
pth_experience + 'Exp_Save//' + next_filename)
# Формируем новые игровые данные с новым агентом.
exp_filename = pth_experience + next_filename
temperature = max(min_temp, temp_decay * temperature)
do_self_play(19,
output_file,
output_file,
num_games=num_games,
temperature=temperature,
experience_filename=exp_filename)
logf.write('Новая "температура" = %f\n' % temperature)
else:
print(
'Агента не меняем, Игровые данные тоже оставляем прежними \n')
total_work += 1
print('Количество выполненных прогонов = ', total_work)
logf.write('Выполнен прогон %d время at %s\n' %
(total_work, datetime.datetime.now()))
# Новая генерация учебных данных.
# num_games += delta_games # Увеличиваем количество игр для обучения.
# #temperature = max(min_temp, temp_decay * temperature)
# next_filename = 'exp_q_' + str(total_work) + '.h5'
# shutil.move(exp_filename, pth_experience + 'Exp_Save//' + next_filename)
# exp_filename = pth_experience + next_filename
# do_self_play(19, current_agent, current_agent, num_games=num_games,
# temperature=0, experience_filename=exp_filename)
#
#
# exp_buffer = rl.load_experience(h5py.File(exp_filename, "r")) # Загружаем в буфер новый файл с играми.
learning_agent = current_agent # Обновляем "предыщуго обучаемого агента
logf.flush()