def test_1_supervised_learning(self): print("TEST 1\n=====================================================") gpus = tf.config.experimental.list_physical_devices('GPU') if gpus: # Restrict TensorFlow to only use the first GPU try: tf.config.experimental.set_visible_devices(gpus[0], 'GPU') tf.config.experimental.set_memory_growth(gpus[0], True) tf.config.set_soft_device_placement(True) except RuntimeError as e: print(e) rows, cols = 19, 19 encoder = AlphaGoEncoder() input_shape = (encoder.num_planes, rows, cols) alphago_sl_policy = alphago_model(input_shape, is_policy_net=True) alphago_sl_policy.compile('sgd', 'categorical_crossentropy', metrics=['accuracy']) alphago_sl_agent = DeepLearningAgent(alphago_sl_policy, encoder) inputs = np.ones((10, ) + input_shape) outputs = alphago_sl_policy.predict(inputs) assert (outputs.shape == (10, 361)) with h5py.File('test_alphago_sl_policy.h5', 'w') as sl_agent_out: alphago_sl_agent.serialize(sl_agent_out)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--epochs', '-e', default=20, type=int, help="Training epochs. Default is 20") args = parser.parse_args() # tag::e2e_processor[] go_board_rows, go_board_cols = 19, 19 nb_classes = go_board_rows * go_board_cols encoder = SevenPlaneEncoder((go_board_rows, go_board_cols)) processor = GoDataProcessor(encoder=encoder.name()) X, y = processor.load_go_data(num_samples=100) # end::e2e_processor[] # tag::e2e_model[] input_shape = (go_board_rows, go_board_cols, encoder.num_planes) model = Sequential() network_layers = drew_example.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=args.epochs, verbose=1) # end::e2e_model[] # tag::e2e_agent[] deep_learning_bot = DeepLearningAgent(model, encoder) fpath = os.path.join(CODE_ROOT_DIR, "agents/deep_bot.h5") model_file = h5py.File(fpath, "w") deep_learning_bot.serialize(model_file) model_file.close()
def main(): # tag::e2e_processor[] go_board_rows, go_board_cols = 19, 19 nb_classes = go_board_rows * go_board_cols encoder = SevenPlaneEncoder((go_board_rows, go_board_cols)) processor = GoDataProcessor(encoder=encoder.name()) X, y = processor.load_go_data(num_samples=100) # end::e2e_processor[] # tag::e2e_model[] input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=20, verbose=1) # end::e2e_model[] # tag::e2e_agent[] deep_learning_bot = DeepLearningAgent(model, encoder) model_file = h5py.File("../agents/deep_bot.h5", "w") deep_learning_bot.serialize(model_file) model_file.close()
def main(): # sl data encoder = AlphaGoEncoder() processor = GoDataProcessor(encoder=encoder.name()) # Paraller Processor generator = processor.load_go_data('train', NUM_GAMES, use_generator=True) test_generator = processor.load_go_data('test', NUM_GAMES, use_generator=True) # Data Processor # todo: does not have use_generator capability # generator = processor.load_go_data('train', NUM_GAMES) # test_generator = processor.load_go_data('test', NUM_GAMES) # sl model input_shape = (encoder.num_planes, ROWS, COLS) alphago_sl_policy = alphago_model(input_shape=input_shape, is_policy_net=True) # read earlier trained bot bot_filepath = 'alphago/alpha_sl_policy_e13_1k.h5' alphago_sl_policy.load_weights(bot_filepath) alphago_sl_policy.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) # sl train epochs = 200 batch_size = 128 alphago_sl_policy.fit_generator( generator=generator.generate(batch_size, NUM_CLASSES), epochs=epochs, steps_per_epoch=generator.get_num_samples() / batch_size, validation_data=test_generator.generate(batch_size, NUM_CLASSES), validation_steps=test_generator.get_num_samples() / batch_size, callbacks=[ModelCheckpoint('alphago_sl_policy_load_train_{epoch}.h5')]) alphago_sl_agent = DeepLearningAgent(alphago_sl_policy, encoder) # save model with h5py.File('alphago_sl_policy_load_train.h5', 'w') as sl_agent_out: alphago_sl_agent.serialize(sl_agent_out) # evaluate alphago_sl_policy.evaluate_generator( generator=test_generator.generate(batch_size, NUM_CLASSES), steps=test_generator.get_num_samples() / batch_size)
def main(): samp = 1000 epo = 1 # tag::e2e_processor[] timestr = time.strftime("%Y%m%d-%H%M%S") model_h5filename = "./agents/deep_bot_" + timestr + "_s" + str( samp) + "e" + str(epo) + ".h5" go_board_rows, go_board_cols = 19, 19 nb_classes = go_board_rows * go_board_cols encoder = XPlaneEncoder((go_board_rows, go_board_cols)) data_dir = "data/" + str(encoder.num_planes) + "-planes" processor = GoDataProcessor(encoder=encoder.name(), data_directory=data_dir) X, y = processor.load_go_data(num_samples=samp) # end::e2e_processor[] # tag::e2e_model[] input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) try: with tf.device('/device:GPU:0'): model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=epo, verbose=1) # end::e2e_model[] # tag::e2e_agent[] deep_learning_bot = DeepLearningAgent(model, encoder) deep_learning_bot.serialize(h5py.File(model_h5filename, "w")) # end::e2e_agent[] # tag::e2e_load_agent[] model_file = h5py.File(model_h5filename, "r") bot_from_file = load_prediction_agent(model_file) web_app = get_web_app({'predict': bot_from_file}) web_app.run() # end::e2e_load_agent[] except RuntimeError as e: print(e)
def test_1_supervised_learning(self): rows, cols = 19, 19 encoder = AlphaGoEncoder() input_shape = (encoder.num_planes, rows, cols) alphago_sl_policy = alphago_model(input_shape, is_policy_net=True) alphago_sl_policy.compile('sgd', 'categorical_crossentropy', metrics=['accuracy']) alphago_sl_agent = DeepLearningAgent(alphago_sl_policy, encoder) inputs = np.ones((10, ) + input_shape) outputs = alphago_sl_policy.predict(inputs) assert (outputs.shape == (10, 361)) with h5py.File('test_alphago_sl_policy.h5', 'w') as sl_agent_out: alphago_sl_agent.serialize(sl_agent_out)
X, y = processor.load_go_data(num_samples=100) # end::e2e_processor[] # tag::e2e_model[] input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=20, verbose=1) # end::e2e_model[] # tag::e2e_agent[] deep_learning_bot = DeepLearningAgent(model, encoder) deep_learning_bot.serialize("../agents/deep_bot.h5") # tag::e2e_agent[] # tag::e2e_load_agent[] model_file = h5py.File("../agents/deep_bot.h5", "r") bot_from_file = load_prediction_agent(model_file) web_app = get_web_app({'predict': bot_from_file}) web_app.run() # end::e2e_load_agent[]
from dlgo.networks import large go_board_rows, go_board_cols = 19, 19 nb_classes = go_board_rows * go_board_cols encoder = SevenPlaneEncoder((go_board_rows, go_board_cols)) processor = GoDataProcessor(encoder=encoder.name()) X, y = processor.load_go_data(num_samples=100) input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=20, verbose=1) deep_learning_bot = DeepLearningAgent(model, encoder) with h5py.File('./agents/deep_bot.h5', 'w') as outf: deep_learning_bot.serialize(outf) model_file = h5py.File('./agents/deep_bot.h5', 'r') bot_from_file = load_prediction_agent(model_file) web_app = get_web_app({'predict': bot_from_file}) web_app.run()
def bot_save(model, encoder, where_save_bot): # Сохранение для бота чтобы играть в браузере с ботом play_predict_19.html deep_learning_bot = DeepLearningAgent(model, encoder) model_file = h5py.File(where_save_bot, "w") deep_learning_bot.serialize(model_file)
rows, cols = 19, 19 num_classes = rows * cols num_games = 10000 encoder = AlphaGoEncoder() processor = GoDataProcessor(encoder=encoder.name()) generator = processor.load_go_data('train', num_games, use_generator=True) test_generator = processor.load_go_data('test', num_games, use_generator=True) input_shape = (encoder.num_planes, rows, cols) alphago_sl_policy = alphago_model(input_shape, is_policy_net=True) alphago_sl_policy.compile('sgd', 'categorical_crossentropy', metrics=['accuracy']) epochs = 200 batch_size = 128 alphago_sl_policy = fit_generator( generator=generator.generate(batch_size, num_classes), epochs=epochs, steps_per_epoch=generator.get_num_samples() / batch_size, validation_data=test_generator.generate(batch_size, num_classes), validation_steps=test_generator.get_num_samples() / batch_size, callbacks=[ModelCheckpoint('alphago_sl_policy_{epoch}.h5')]) alphago_sl_agent = DeepLearningAgent(alphago_sl_policy, encoder) with h5py.File('alphago_sl_policy.h5', 'w') as sl_agent_out: alphago_sl_agent.serialize(sl_agent_out)
input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=args.optimizer, metrics=['accuracy']) model.fit(X, y, batch_size=args.batch_size, epochs=args.epochs, verbose=1) deep_learning_bot = DeepLearningAgent(model, encoder) try: deep_learning_bot.serialize( h5py.File("./agents/{}_bot.h5".format(args.bot_name))) print("Saving {}_bot.h5 to agents/".format(args.bot_name)) except ValueError as e: print(e) new_name = input("Please enter a different name : ") deep_learning_bot.serialize( h5py.File("./agents/{}_bot.h5".format(new_name))) print("Saving {}_bot.h5 to agents/".format(new_name)) # model_file = h5py.File("./agents/deep_bot_3.h5", "r") # bot_from_file = load_prediction_agent(model_file) # web_app = get_web_app({'predict': bot_from_file}) # web_app.run()
model.add(Dropout(rate=0.6)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(rate=0.6)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(rate=0.6)) model.add(Dense(size * size, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.fit(X_train, Y_train, batch_size=64, epochs=5, verbose=1, validation_data=(X_test, Y_test)) score = model.evaluate(X_test, Y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) encoder = SevenPlaneEncoder((19, 19)) dlAgent = DeepLearningAgent(model, encoder) with h5py.File('cnn_agent.h5', 'w') as dlAgent_out: dlAgent.serialize(dlAgent_out) # time.sleep(15)
X, y = processor.load_go_data(num_samples=100) # end::e2e_processor[] # tag::e2e_model[] input_shape = (encoder.num_planes, go_board_rows, go_board_cols) model = Sequential() network_layers = large.layers(input_shape) for layer in network_layers: model.add(layer) model.add(Dense(nb_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X, y, batch_size=128, epochs=20, verbose=1) # end::e2e_model[] # tag::e2e_agent[] deep_learning_bot = DeepLearningAgent(model, encoder) deep_learning_bot.serialize(h5py.File("../agents/deep_bot.h5", "w")) # end::e2e_agent[] # tag::e2e_load_agent[] model_file = h5py.File("../agents/deep_bot.h5", "r") bot_from_file = load_prediction_agent(model_file) web_app = get_web_app({'predict': bot_from_file}) web_app.run() # end::e2e_load_agent[]