def testRun():
# MNIST dataset
train_dataset = torchvision.datasets.MNIST(root='/data',
train=True,
transform=transforms.ToTensor(),
download=True)
cv_splits = 3
kfold = KFold(n_splits=cv_splits, shuffle=True, random_state=0)
for fold_idx, (train_idx,
valid_idx) in enumerate(kfold.split(train_dataset)):
print(">> CV fold step ", str(fold_idx))
# cnn model
model = mlp.SimpleMLP(output_classes).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# Data loader
train_loader = DataLoader(Subset(train_dataset, train_idx),
batch_size=batch_size,
shuffle=True)
# Training
mnist_trainer = trainer.MLPTrainer(train_loader,
model=model,
cri=criterion,
opt=optimizer,
device=device)
train_result = mnist_trainer.Execute(epochs)
def mlp(X_train, y_train, X_test, y_test):
# mlp
mlp = MLP(X_train, y_train, X_test, y_test)
# mlp train
mlp.mlp_train()
# save model
# predict
mlp_predict = mlp.mlp_predict_classes().reshape(len(X_test), )
# predict probability
mlp_predict_prob = mlp.mlp_predict_prob()
mlp_predict_prob = np.hstack((1 - mlp_predict_prob, mlp_predict_prob))
return [mlp, mlp_predict + 1, mlp_predict_prob]
def run(self): # 把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
if self.model_map[self.threadID] == "Rule_based":
# 等待Hello
protobufhello = self.tcpCliSock.recv(BUFSIZ)
hello_message = message.Hello()
hello_message.ParseFromString(protobufhello)
print(hello_message)
print("Hello")
hello_message.code = 1 # Rule_based
self.tcpCliSock.send(hello_message.SerializeToString())
while True:
print("is recving")
protobufdata = self.tcpCliSock.recv(BUFSIZ)
print("recv")
game_state_message = message.GameState() # 读取GameState
game_state_message.ParseFromString(protobufdata)
player = game_state_message.who
if player == 0:
# Declare
card = declarer(game_state_message, "hard")
# 发送
elif player == 1:
card = lopp(game_state_message, "hard")
elif player == 2:
card = dummy(game_state_message, "hard")
else:
card = ropp(game_state_message, "hard")
play = message.Play()
play.who = player
play.card.CopyFrom(card)
self.tcpCliSock.send(play.SerializeToString())
print("play")
elif self.model_map[self.threadID] == "DQN_SL":
device = torch.device('cpu')
net = DQN().to(device)
net.eval()
net.load_state_dict(torch.load('models/trained_agents/bridge_agent_14-16_v5.pth', map_location=torch.device('cpu')))
protobufhello = self.tcpCliSock.recv(BUFSIZ)
hello_message = message.Hello()
hello_message.ParseFromString(protobufhello)
print(hello_message)
print("Hello")
hello_message.code = 2
self.tcpCliSock.send(hello_message.SerializeToString())
while True:
print("is recving")
protobufdata = self.tcpCliSock.recv(BUFSIZ)
print("recv")
game_state_message = message.GameState() # 读取GameState
game_state_message.ParseFromString(protobufdata)
player = game_state_message.who
feature = GameState2feature_DQN(game_state_message)
card_logits = net(torch.tensor(feature).float())
# 加一层mask
validPlays = game_state_message.validPlays
output_mask = [0] * 52
for card in validPlays:
output_mask[card.suit * 13 + card.rank] = 1
masked_logits = card_logits.data * torch.tensor(output_mask) + torch.tensor(output_mask)
pred = masked_logits.max(0)[1]
card = message.Card()
card.suit = int(int(pred) / 13)
card.rank = int(pred) % 13
play = message.Play()
play.who = player
play.card.CopyFrom(card)
self.tcpCliSock.send(play.SerializeToString())
print("play")
elif self.model_map[self.threadID] == "DQN_RL":
device = torch.device('cpu')
net = [DQN().to(device) for i in range(4)]
map_dirname = {0:'declarer',1:'lopp',2:'dummy',3:'ropp'}
for i in range(4):
net[i].eval()
net[i].load_state_dict(torch.load('models/DQN/'+map_dirname[i]+'/policy-network-30000.pth', map_location=torch.device('cpu')))
protobufhello = self.tcpCliSock.recv(BUFSIZ)
hello_message = message.Hello()
hello_message.ParseFromString(protobufhello)
print(hello_message)
print("Hello")
hello_message.code = 3
self.tcpCliSock.send(hello_message.SerializeToString())
while True:
print("is recving")
protobufdata = self.tcpCliSock.recv(BUFSIZ)
print("recv")
game_state_message = message.GameState() # 读取GameState
game_state_message.ParseFromString(protobufdata)
player = game_state_message.who
feature = GameState2feature_DQN(game_state_message)
card_logits = net[player](torch.tensor(feature).float())
# 加一层mask
validPlays = game_state_message.validPlays
output_mask = [0] * 52
for card in validPlays:
output_mask[card.suit * 13 + card.rank] = 1
masked_logits = card_logits.data * torch.tensor(output_mask) + torch.tensor(output_mask)
pred = masked_logits.max(0)[1]
card = message.Card()
card.suit = int(int(pred) / 13)
card.rank = int(pred) % 13
play = message.Play()
play.who = player
play.card.CopyFrom(card)
self.tcpCliSock.send(play.SerializeToString())
print("play")
elif self.model_map[self.threadID] == "MLP":
device = torch.device('cpu')
net = MLP().to(device)
net.load_state_dict(torch.load('models/SL_V1.pth', map_location=torch.device('cpu')))
protobufhello = self.tcpCliSock.recv(BUFSIZ)
hello_message = message.Hello()
hello_message.ParseFromString(protobufhello)
print(hello_message)
print("Hello")
hello_message.code = 2
self.tcpCliSock.send(hello_message.SerializeToString())
while True:
print("is recving")
protobufdata = self.tcpCliSock.recv(BUFSIZ)
print("recv")
game_state_message = message.GameState() # 读取GameState
game_state_message.ParseFromString(protobufdata)
player = game_state_message.who
feature = GameState2feature_MLP(game_state_message)
card_logits = net(torch.tensor(feature).float())
# 加一层mask
validPlays = game_state_message.validPlays
output_mask = [0] * 52
for card in validPlays:
output_mask[card.suit * 13 + card.rank] = 1
masked_logits = card_logits.data * torch.tensor(output_mask) + torch.tensor(output_mask)
pred = masked_logits.max(0)[1]
card = message.Card()
card.suit = int(int(pred) / 13)
card.rank = int(pred) % 13
play = message.Play()
play.who = player
play.card.CopyFrom(card)
self.tcpCliSock.send(play.SerializeToString())
print("play")
elif self.model_map[self.threadID] == "CNN_SL":
device = torch.device('cpu')
net = ConvFCNet().to(device)
model = torch.load('models/cnn_model.pkl',map_location=torch.device('cpu'))
if isinstance(model, torch.nn.DataParallel):
net = model.module
net.eval()
protobufhello = self.tcpCliSock.recv(BUFSIZ)
hello_message = message.Hello()
hello_message.ParseFromString(protobufhello)
print(hello_message)
print("Hello")
hello_message.code = 2
self.tcpCliSock.send(hello_message.SerializeToString())
while True:
print("is recving")
protobufdata = self.tcpCliSock.recv(BUFSIZ)
print("recv")
game_state_message = message.GameState() # 读取GameState
game_state_message.ParseFromString(protobufdata)
player = game_state_message.who
feature = GameState2feature_cnn(game_state_message)
card_logits = net(torch.tensor(feature).float()[None,:])
resort_card_logits = torch.zeros_like(card_logits[0])
resort_card_logits[:13] = card_logits[0,-13:]
resort_card_logits[13:26] = card_logits[0,-26:-13]
resort_card_logits[26:39] = card_logits[0,13:26]
resort_card_logits[-13:] = card_logits[0,0:13]
# 加一层mask
validPlays = game_state_message.validPlays
output_mask = [0] * 52
for card in validPlays:
output_mask[card.suit * 13 + card.rank] = 1
masked_logits = torch.nn.functional.softmax(resort_card_logits, 0).data * torch.tensor(output_mask) + torch.tensor(output_mask)
pred = masked_logits.max(0)[1]
card = message.Card()
card.suit = int(int(pred) / 13)
card.rank = int(pred) % 13
play = message.Play()
play.who = player
play.card.CopyFrom(card)
self.tcpCliSock.send(play.SerializeToString())
print("play")
config.batch_size,
config.epoch,
padding=True,
sort=False)
train_sim_iter = batch_sort_iter(train_sim,
config.batch_size,
config.epoch,
padding=False)
# large dev evaluation will result in memory issue
N = 1000
dev_q_t = to_tensor(dev_q[:N], padding=True)
dev_a_t = to_tensor(dev_a[:N], padding=True, sort=False)
dev_sim_t = torch.LongTensor(dev_sim[:N])
model = MLP(config)
optimizer = optim.SGD(model.parameters(), lr=config.lr)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
dev_q_t, dev_a_t, dev_sim_t = dev_q_t.to(device), dev_a_t.to(
device), dev_sim_t.to(device)
#pdb.set_trace()
def train():
cnt = 0
pbar = tqdm(zip(train_q_iter, train_a_iter, train_sim_iter),
total=n_batches)
val_loss = -1
def RunTorchCV():
with mlflow.start_run():
# MNIST dataset
train_dataset = torchvision.datasets.MNIST(
root='/data',
train=True,
transform=transforms.ToTensor(),
download=True)
train_results = {}
valid_results = {}
cv_splits = 3
kfold = KFold(n_splits=cv_splits, shuffle=True, random_state=0)
for fold_idx, (train_idx,
valid_idx) in enumerate(kfold.split(train_dataset)):
print(">> CV fold step ", str(fold_idx))
# cnn model
model = mlp.SimpleMLP(output_classes).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# Data loader
train_loader = DataLoader(Subset(train_dataset, train_idx),
batch_size=batch_size,
shuffle=True)
valid_loader = DataLoader(Subset(train_dataset, valid_idx),
batch_size=batch_size,
shuffle=False)
# Training
mnist_trainer = trainer.MLPTrainer(train_loader,
model=model,
cri=criterion,
opt=optimizer,
device=device)
train_result = mnist_trainer.Execute(epochs)
trained_model = mnist_trainer.GetModel()
train_results[fold_idx] = train_result
# Validation
mnist_validator = validator.MLPValidator(valid_loader,
model=trained_model,
criterion=criterion,
device=device)
valid_result = mnist_validator.Validate()
valid_results[fold_idx] = valid_result
mlflow.log_param("method_name",
mlp.SimpleMLP(output_classes).__class__.__name__)
mlflow.log_param("output_class", output_classes)
mlflow.log_param("batch_size", batch_size)
mlflow.log_param("learning_rate", learning_rate)
mlflow.log_param("fold_type", kfold.__class__.__name__)
mlflow.log_param("n_splits", cv_splits)
mlflow.log_param("random_state", 0)
mlflow.log_param("criterion", nn.CrossEntropyLoss.__class__.__name__)
mlflow.log_param("optimizer", torch.optim.Adam.__name__)
average_loss = 0
average_acc = 0
for fold_idx, cv_result in train_results.items():
loss = cv_result[cv_splits - 1]["loss"]
acc = cv_result[cv_splits - 1]["accuracy"]
average_loss += loss
average_acc += acc
mlflow.log_metric("fold_" + str(fold_idx) + "_loss", loss)
mlflow.log_metric("fold_" + str(fold_idx) + "_accuracy", acc)
average_loss = average_loss / cv_splits
average_acc = average_acc / cv_splits
mlflow.log_metric("average_loss", average_loss)
mlflow.log_metric("average_acc", average_acc)
return valid_results
#!/usr/bin/python
from __future__ import division
from config import config
from utils import *
from data_loader import *
import pdb
from Model import MLP
from tqdm import tqdm
# dump path
train_file_path = "./pkl/reader/300/train_pair.pkl"
dev_file_path = "./pkl/reader/300/dev_pair.pkl"
test_file_path = "./pkl/reader/300/test_pair.pkl"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = MLP(config)
model = model.to(device)
model.load(config.pre_embed_file)
title_dict = load_from_file(config.title_dict)
entity_dict = load_from_file(config.entity_dict)
def predict_sim(x, y):
x = torch.LongTensor([x])
y = torch.LongTensor([y])
sim = torch.LongTensor([1])
x, y, sim = x.to(device), y.to(device), sim.to(device)
#pdb.set_trace()
loss = model.forward(x, y, sim)
return loss.item()
with open('letter-recognition.data', 'r') as file:
lines = file.readlines()
data = []
for line in lines:
values = line.split(',')
# Divide by 15 for Min Max Normalisation
input = [(int(x.replace('\n', '')) / 15) for x in values[1:]]
label = charToOneHot(values[0])
data.append([input, label])
dataSet = DataSet(data, 0.8)
# Load or insantiate new MLP
if len(sys.argv) == 1:
mlp = MLP(dataSet.numInputs, numHidden, dataSet.numOutputs, outputActivation='SOFTMAX', hiddenActivation=hiddenActivation)
train = True
elif sys.argv[1] == 'load':
mlp = MLP(loadModel=True)
train = False
numEpochs = 1
# Train and test
for epoch in range(numEpochs):
trainLoss, trainAccuracy = mlp.process(dataSet.trainData, train=train, learningRate=learningRate, updateFreq=updateFreq)
if epoch % printFreq == 0 or epoch == numEpochs - 1:
testLoss, testAccuracy = mlp.process(dataSet.testData, train=False)
print("EPOCH: ", epoch)
print("TRAIN LOSS: ", trainLoss)
print("TRAIN ACC: ", trainAccuracy, "%")
print("TEST LOSS: ", testLoss)
[[1, 1], [1, 0]]])
# Best learning rates for each determined through experimenting
if outputActivation == 'SIGMOID':
dataSet = dataSet1
learningRate = 1
if outputActivation == 'TANH':
dataSet = dataSet2
learningRate = 1
if outputActivation == 'RELU':
dataSet = dataSet1
learningRate = 0.01
if outputActivation == 'SOFTMAX':
dataSet = dataSet3
learningRate = 0.1
if 'dataSet' not in list(locals()) + list(globals()):
print("\'" + outputActivation + "\' is not a valid activation function.")
sys.exit()
mlp = MLP(dataSet.numInputs, 2, dataSet.numOutputs, outputActivation,
hiddenActivation)
for epoch in range(numEpochs):
epochLoss, epochAccuracy = mlp.process(dataSet.trainData,
train=True,
learningRate=learningRate)
if epoch % printFreq == 0:
print("EPOCH: ", epoch)
print("TRAIN LOSS: ", epochLoss)
print("TRAIN ACC: ", epochAccuracy, "%\n")
#!/usr/bin/python
from __future__ import division
from config import config
from utils import *
from data_loader import *
import pdb
from Model import MLP
# dump path
train_file_path = "./pkl/reader/300/train_pair.pkl"
dev_file_path = "./pkl/reader/300/dev_pair.pkl"
test_file_path = "./pkl/reader/300/test_pair.pkl"
model = MLP(config)
model.load(config.pre_embed_file)
title_dict = load_from_file(config.title_dict)
entity_dict = load_from_file(config.entity_dict)
def predict_sim(x, y):
x = torch.LongTensor([x])
y = torch.LongTensor([y])
sim = torch.LongTensor([1])
#pdb.set_trace()
loss = model.forward(x, y, sim)
return loss.data.numpy()[0]
def extract_ans_pair(golds, wiki_ans):
s1 = set(golds)