def data_generate(size=4,
score_to_win=zit_score_to_win,
AgentClass=GenerateDataAgent,
**kwargs):
game = Game(size, score_to_win)
agent = AgentClass(game, display=Display(), **kwargs)
train_data, train_label = agent.play()
return train_data, train_label
def single_run(logger, models, size, score_to_win, AgentClass, **kwargs):
game = Game(size, score_to_win)
agent = AgentClass(logger=logger,
models=models,
game=game,
display=Display(),
**kwargs)
agent.play(verbose=True)
return game.score
def single_run(size, model1, model2, model3, score_to_win, AgentClass,
**kwargs):
game = Game(size, score_to_win)
agent = AgentClass(model1,
model2,
model3,
game,
display=Display(),
**kwargs)
agent.play(verbose=False)
return game.score
import keras
from game2048.game import Game
from game2048.displays import Display, IPythonDisplay
from game2048.agents import ExpectiMaxAgent, Agent2
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization
from keras.optimizers import Adam
import numpy as np
from sklearn.model_selection import train_test_split
BATCH_SIZE = 128
NUM_CLASSES = 4
NUM_EPOCHS = 20
display1 = Display()
display2 = IPythonDisplay()
model = keras.models.load_model('model.h5')
image = []
label = []
for i in range(0, 10):
game = Game(4, score_to_win=2048, random=False)
agent = ExpectiMaxAgent(game, display=display1)
while game.end == False:
direction = agent.step()
image.append(game.board)
label.append(direction)
game.move(direction)
import keras
BATCH_SIZE = 128
NUM_CLASSES = 4
NUM_EPOCHS = 20
from game2048.game import Game
from game2048.displays import Display, IPythonDisplay
from game2048.agents import ExpectiMaxAgent
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization
from keras.optimizers import Adam
import numpy as np
from sklearn.model_selection import train_test_split
display1 = Display()
display2 = IPythonDisplay()
model = load_model('2048_new2_2048.h5')
image = []
label = []
#清空棋盘和方向的矩阵
count1 = 0
while count1 < 1:
count = 0
for j in range(0, 50):
game = Game(4, score_to_win=1024, random=False)
agent1 = ExpectiMaxAgent(game)
#agent2 = MyOwnAgent(game, display=display1)
while game.end == False:
direction1 = agent1.step() #用强Agent判断方向
def single_run(size, ds, AgentClass, **kwargs):
game = Game(size, 2048)
agent = AgentClass(game, display=Display(), **kwargs)
agent.play(dataset=ds, verbose=False, train=1)
def single_run(board_data, move_data, size, score_to_win, AgentClass, **kwargs):
game = Game(size, score_to_win)
agent = AgentClass(board_data=board_data, move_data=move_data, game=game, display=Display(), **kwargs)
agent.play(verbose=True)
return game.score
import numpy as np
from game2048.game import Game
from game2048.agents import ExpectiMaxAgent
from game2048.agents import MyAgent
from game2048.displays import Display
import csv
import os
game_size = 4
score_to_win = 2048
iter_num = 3000
game = Game(game_size, score_to_win)
board = game.board
agenta = ExpectiMaxAgent(game, Display())
agentb = MyAgent(game, Display())
directiona = agenta.step()
directionb = agentb.step()
board = game.move(directionb)
i = 0
dic = {}
idx = 0
# save file
filename = '/home/olivia/PycharmProjects/2048/game2048/data/traindata10.csv'
if os.path.exists(filename):
start = True
else:
start = False
os.mknod(filename)
from game2048.agents import ExpectiMaxAgent
from game2048.game import Game
from game2048.my_agents import TrainAgent, TrainAgent2, TrainAgent_12
from game2048.displays import Display
import torch
GAME_SIZE = 4
SCORE_TO_WIN = 2048
N_TESTS = 10
game = Game(GAME_SIZE, SCORE_TO_WIN)
agent = TrainAgent2(game,
display=Display(),
load_data=True,
train=False,
path='model3_dict_01_11.pkl')
for _ in range(50):
agent.play(verbose=False)
agent.new_game(game=Game(GAME_SIZE, SCORE_TO_WIN))
print('Average time per step: {}'.format(agent.t / agent.step_counter))
print(agent.statistics)
print('steps: {}, errors: {}, differents: {}'.format(agent.step_counter,
agent.error_counter,
agent.diff_counter))
# torch.save(agent.net.state_dict(), 'model.pkl')
NUM_CLASSES = 4 #分类数目
NUM_EPOCHS = 20 #训练的迭代次数
from game2048.game import Game
from game2048.displays import Display
from game2048.agents import ExpectiMaxAgent,MyOwnAgent
from keras.models import Sequential,load_model
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
from keras.optimizers import RMSprop
import numpy as np
from sklearn.model_selection import train_test_split
image=[]
label=[]
display1 = Display()
display2 = Display()
stop_number = 2048
size = int(np.log2(stop_number)) +1 #跑到stop number时所需的one-hot编码位数
for i in range(0,500): #跑500次棋盘，跑到stop_number停止
game = Game(4, score_to_win=2048, random=False)
agent = ExpectiMaxAgent(game, display=display1) #使用强Agent
while game.end==False:
a=np.array(game.board)
direction=agent.step()
image.append(game.board)
label.append(direction)
if __name__ == '__main__':
GAME_SIZE = 4
SCORE_TO_WIN = 2048
N_TESTS = 50
'''====================
Use your own agent here.'''
from game2048.agents import MyAgent as TestAgent
'''===================='''
size = 4
score_to_win = 2048
# 59*16*12
game = Game(size, score_to_win)
agent = TestAgent(game, display=Display())
scores = []
agent.net7.load_state_dict(
torch.load("net_3_params_7.pkl", map_location='cpu'))
agent.net6.load_state_dict(
torch.load("net_3_params_6.pkl", map_location='cpu'))
agent.net5.load_state_dict(
torch.load("net_3_params_5.pkl", map_location='cpu'))
agent.net4.load_state_dict(
torch.load("net_3_params_4.pkl", map_location='cpu'))
agent.net2.load_state_dict(
torch.load("net_3_params_2.pkl", map_location='cpu'))
step = 0
for i in range(N_TESTS):
"score": game.score,
"end": game.end,
"direction": direction,
"control": control
})
return app
if __name__ == "__main__":
GAME_SIZE = 4
SCORE_TO_WIN = 8192
APP_PORT = 5009
APP_HOST = "0.0.0.0"
from game2048.game import Game
game = Game(size=GAME_SIZE, score_to_win=SCORE_TO_WIN)
from game2048.agents import MonteCarloAgent
print("WARNING: You are now using a MonteCarloAgent.")
agent = MonteCarloAgent(game=game, display=Display())
agent.play(verbose=True)
print("Run the webapp at http://<any address for your local host>:%s/" %
APP_PORT)
if game.score > 2048:
APP_PORT += 1
app = get_flask_app(game, agent)
app.run(port=APP_PORT, threaded=False, host=APP_HOST
) # IMPORTANT: `threaded=False` to ensure correct behavior
from game2048.game import Game
from game2048.my_agents import TrainAgent
from game2048.HierarchicalAgent import HierarchicalAgent
from game2048.displays import Display
import torch
GAME_SIZE = 4
SCORE_TO_WIN = 4096
N_TESTS = 10
PATH = ('model3_dict_01_11.pkl', 'model3_dict1.pkl')
SAVE_PATH = ('model3_dict0.pkl', 'model3_dict1.pkl')
game = Game(GAME_SIZE, SCORE_TO_WIN, random=False)
agent = HierarchicalAgent(game, display=Display(), load_data=True, path=PATH)
for i in range(2000):
agent.play(verbose=False)
print("Game: {} Score: {}".format(i, agent.game.score))
agent.new_game(game=Game(GAME_SIZE, SCORE_TO_WIN, random=False))
agent.threshold *= 0.99
# print("Steps: {} Errors: {}".format(agent.step_counter, agent.error_counter))
if (i+1) % 100 == 0:
torch.save(agent.net0.state_dict(), SAVE_PATH[0])
torch.save(agent.net1.state_dict(), SAVE_PATH[1])
print(agent.statistics)
torch.save(agent.net0.state_dict(), SAVE_PATH[0])
torch.save(agent.net1.state_dict(), SAVE_PATH[1])
author: 赵阳桁
Trian model from pre-trained model
"""
from game2048.agents import ExpectiMaxAgent
from game2048.game import Game
from game2048.my_agents import TrainAgent, TrainAgent2
from game2048.displays import Display
import torch
GAME_SIZE = 4
SCORE_TO_WIN = 4096
N_TESTS = 10
PATH = 'model3_dict_01_11.pkl'
SAVE_PATH = 'model3_dict_new.pkl'
game = Game(GAME_SIZE, SCORE_TO_WIN, random=False)
agent = TrainAgent2(game, display=Display(), load_data=True, path=PATH)
for i in range(2000):
agent.play(verbose=False)
print("Game: {} Score: {}".format(i, agent.game.score))
agent.new_game(game=Game(GAME_SIZE, SCORE_TO_WIN, random=False))
agent.threshold *= 0.99
print("Steps: {} Errors: {}".format(agent.step_counter,agent.error_counter))
if (i+1)%100 == 0:
torch.save(agent.net.state_dict(),SAVE_PATH)
print(agent.statistics)
torch.save(agent.net.state_dict(), SAVE_PATH)
# torch.save(agent.net, 'model.pkl')
def single_run(size, score_to_win, AgentClass, model):
game = Game(size, score_to_win)
agent = AgentClass(game, display=Display())
agent.import_model(model)
agent.play(max_iter=5e3, verbose=False)
return game.score
from models.Final_Model import RCNN_model
model = RCNN_model()
model.load_weights("checkpoints/checkpoint.hdf5")
def reshape_board(board):
res = np.zeros((4, 4), dtype=float)
for i in range(4):
for j in range(4):
k = int(board[i, j])
if k != 0:
res[i, j] = np.log2(k) / 11
res1 = res.T
return np.hstack((res, res1))
game3 = Game(score_to_win=2048, random=False)
display3 = Display()
while game3.end == 0:
display3.display(game3)
# agent1 = ExpectiMaxAgent(game3)
board = np.array([reshape_board(game3.board)])
prediction = model.predict(board)
step = np.argmax(prediction, axis=1)
# step = agent1.step()
game3.move(step)
def single_run(size, score_to_win, AgentClass, sess):
game = Game(size, score_to_win)
agent = AgentClass(game, display=Display(), sess=sess)
agent.build()
agent.play(verbose=True)
return game.score
import sys
sys.path.append("..")
from game2048.expectimax import board_to_move
from game2048.game import Game
from game2048.agents import ExpectiMaxAgent
from game2048.displays import Display
import csv, os
GAME_SIZE = 4
SCORE_TO_WIN = 2048
iter_num = 300
game = Game(GAME_SIZE, SCORE_TO_WIN)
board = game.board
agent = ExpectiMaxAgent(game, Display())
direction = agent.step()
board = game.move(direction)
i = 0
dic = {}
idx = 0
# ------------------------------------------------------
# save each board and its direction to a dict
# -------------------------------------------------------
filename = '/home/zhouykai/Workspace/MachinceLearning/Dataset_2048/Train.csv'
# filename = './Dataset/Train.csv'
if os.path.exists(filename):
head = True
else:
def single_run(size, score_to_win, AgentClass, **kwargs):
game = Game(size, score_to_win)
agent = AgentClass(game, display=Display(), **kwargs)
agent.play(verbose=True)
return game.score
else:
print("Oh! No!")
return train_data, train_label
# In[4]:
data_path = '/home/srtp/ML/2048-api-master/2048-api-master/cnn_train_data/'
print(data_path)
game_size = 4
zit_score_to_win = 2048
AgentClass = GenerateDataAgent
game = Game(game_size, zit_score_to_win)
agent = AgentClass(game, display=Display())
# In[5]:
def data_generate(size=4,
score_to_win=zit_score_to_win,
AgentClass=GenerateDataAgent,
**kwargs):
game = Game(size, score_to_win)
agent = AgentClass(game, display=Display(), **kwargs)
train_data, train_label = agent.play()
return train_data, train_label
# In[6]: