class Testing:
def __init__(self, trainedModel, pathTest, batchSize, imageSize):
super(Testing, self).__init__()
self.model = ConvNet(10)
state_dict = torch.load(trainedModel)
self.model.load_state_dict(state_dict)
self.pathTest = pathTest
self.imageSize = imageSize
self.batchSize = batchSize
self.data_size = calculate_data_size(self.pathTest)
self.data_loader = run_loader('test', self.pathTest, self.batchSize, self.imageSize, shuffle=False)
self.test()
def test(self):
self.model.eval()
acc = 0
y_hat = []
y_true = []
for X, y in tqdm(self.data_loader):
out = self.model(X)
predictions = torch.argmax(out, 1)
acc += torch.sum(predictions == y).item()
y_hat.append(predictions)
y_true.append(y)
y_hat = torch.cat(y_hat)
y_true = torch.cat(y_true)
acc = acc / self.data_size
print(acc)
print(classification_report(y_hat, y_true))
def main(args):
args.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('device: {}'.format(args.device))
# create model
model = ConvNet(cfg.NUM_CLASSES).to(args.device)
# define loss function (criterion)
criterion = nn.CrossEntropyLoss().to(args.device)
# load checkpoint
if args.model_weight:
if os.path.isfile(args.model_weight):
print("=> loading checkpoint '{}'".format(args.model_weight))
checkpoint = torch.load(args.model_weight, map_location=args.device)
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.model_weight))
else:
print("=> no checkpoint found at '{}'".format(args.model_weight))
# Data loading code
test_dataset = ImageFolder(cfg.TEST_PATH, mode='test')
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# Evaluate on test dataset
validate(test_loader, model, criterion, args)
def inference_model(network,lstm_out,out_format,model_path):
doa_classes = DoaClasses()
if out_format == "cartesian":
out_dim = 3
elif out_format == "class":
out_dim = len(doa_classes.classes)
if network == "CNN":
model = ConvNet(device, Dropouts(0,0,0), out_dim, doa_classes)
elif network == "CRNN":
model = CRNN(device, Dropouts(0,0,0), out_dim, doa_classes, lstm_out)
model.load_state_dict(torch.load(model_path,map_location=device))
model.eval()
model.to(device)
return model,doa_classes
def run_inference(model_dir=None, model_path=None, test_data_path=None):
hp_file = model_dir + 'hp.pkl'
f = open(hp_file, "rb")
hp = pickle.load(f)
model = ConvNet().to(device)
ckpt = torch.load(model_dir + model_path, map_location=device)
model.load_state_dict(ckpt['net'])
batch_size = 100
dataset = TestDataGenerator(test_data_path)
iterator = DataLoader(dataset=dataset,
batch_size=batch_size,
num_workers=hp['num_workers'],
pin_memory=True,
shuffle=False,
drop_last=True)
prediction = np.zeros(10000)
with torch.no_grad():
for i, img in enumerate(iterator):
print(i)
img = img.to(device, dtype=torch.float)
logits = model(img)
logits = logits.detach().cpu().numpy()
pred_label = np.argmax(logits, axis=1)
pred_label = pred_label + 1 # class numbers 1 - 10, predicted labels 0 - 9
prediction[i * batch_size:i * batch_size + batch_size] = pred_label
test_image_names = os.listdir(test_data_path)
for i, name in enumerate(test_image_names):
test_image_names[i] = test_image_names[i][0:5]
with open(model_dir + 'predictions.csv', 'w') as f:
writer = csv.writer(f, delimiter=',')
writer.writerow(['Id', 'Category'])
for i in range(len(test_image_names)):
writer.writerow([test_image_names[i], int(prediction[i])])
def main():
# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("Using device: ", device)
model = ConvNet().to(device)
try:
model.load_state_dict(torch.load(FILE))
print("Finished loading model.")
model.eval()
except IOError:
print("Failed to load model. Model might not exist.")
return
print("Print Network Parameters:")
for param in model.parameters():
print(param)
print("Print model state dict: ", model.state_dict())
with torch.no_grad():
print("Perform inference/testing here...")
with open('char_dict', 'rb') as f:
class_dict = pickle.load(f)
num_classes = len(class_dict)
# 读取数据
transform = transforms.Compose([
transforms.Resize((64, 64)),
transforms.ToTensor(),
])
dataset = HWDB(path=data_path, transform=transform)
print("训练集数据:", dataset.train_size)
print("测试集数据:", dataset.test_size)
trainloader, testloader = dataset.get_loader(batch_size)
net = ConvNet(num_classes)
if torch.cuda.is_available():
net = net.cuda()
net.load_state_dict(torch.load('checkpoints/handwriting_iter_009.pth'))
print('网络结构：\n')
#summary(net, input_size=(3, 64, 64), device='cuda')
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=lr)
writer = SummaryWriter(log_path)
for epoch in range(10, epochs):
train(epoch, net, criterion, optimizer, trainloader, writer=writer)
valid(epoch, net, testloader, writer=writer)
print("epoch%d 结束, 正在保存模型..." % epoch)
torch.save(net.state_dict(),
save_path + 'handwriting_iter_%03d.pth' % epoch)
os.makedirs(args.output_dir)
if not os.path.isdir(os.path.join(args.output_dir, args.img_folder)):
os.makedirs(os.path.join(args.output_dir, args.img_folder))
out_name = os.path.join(args.output_dir, args.img_folder)
#--------------------------------#
face_dataset = ImageData(root_dir=args.input_dir,\
transform=transforms.Compose([PreprocessData(args.scale_size, args.crop_size, mode= args.mode)]))
dataloader = DataLoader(face_dataset, batch_size=args.batch_size, shuffle=True)
#--------------- Load Weights ----------------#
net = ConvNet(3, args.K).to(device)
checkpoint = torch.load(os.path.join(args.output_dir, args.checkpoint))
net.load_state_dict(checkpoint['model_state_dict'])
#---------------------------------------------#
#-------------visualize----------------------#
net.eval()
with torch.no_grad():
clr = landmark_colors(args.K)
for i_batch, sample_batched in enumerate(dataloader):
i_image = sample_batched['image']
i_name = sample_batched['name'][0].split("/")[-1]
print(i_name)
i_image = i_image.float().to(device)
out = net(i_image)
std=[0.229, 0.224, 0.225])
])
return trans(img)
# input
img = load_image(args.image)
img = img.unsqueeze(0).to(device)
# create model
model = ConvNet(cfg.NUM_CLASSES).to(device)
# load checkpoint
if args.model_weight:
if os.path.isfile(args.model_weight):
print("=> loading checkpoint '{}'".format(args.model_weight))
checkpoint = torch.load(args.model_weight, map_location=device)
model.load_state_dict(checkpoint['state_dict'])
else:
print("=> no checkpoint found at '{}'".format(args.model_weight))
# predict
model.eval()
with torch.no_grad():
scores = model(img)
probability = torch.nn.functional.softmax(scores, dim=1)
max_value, index = torch.max(probability, 1)
print('pred_label:{}, pred_class:{}, conf:{:.6f}'.format(
index.item(), idx_to_class[index.item()], max_value.item()))
test_loader = DataLoader(test_set,
batch_size=batch_size,
shuffle=False,
num_workers=4,
pin_memory=True)
model = ConvNet(n_in=7, n_features=64, height=128, width=256,
droprate=0).float()
model.to(device)
print("ConvNet initialized")
# model = ResNet(n_in=7, n_features=16, height=128, width=256, droprate=0, num_blocks=2).float()
# model.to(device)
# print("ResNet initialized")
model.load_state_dict(
torch.load("../Models/ConvNet_final", map_location=device))
model.eval()
print("Model loaded")
classes = test_loader.dataset.get_image_classes()
test_correct = 0
class_correct = list(0. for i in range(len(classes)))
class_total = list(0. for i in range(len(classes)))
class_pred = list(0. for i in range(len(classes)))
pred_ = []
target_ = []
for data, target, scaler in test_loader:
data, scaler = data.to(device), scaler.to(device)
with torch.no_grad():
output = model(data)
images=test_data)
eval_dataset = MillionBlocksDataset(labels_arr=eval_labels_arr,
images=eval_data)
train_loader = DataLoader(train_dataset,
batch_size=test_batch_size,
shuffle=False)
test_loader = DataLoader(test_dataset,
batch_size=test_batch_size,
shuffle=False)
eval_loader = DataLoader(eval_dataset,
batch_size=test_batch_size,
shuffle=False)
# ConvNet model
model = ConvNet(num_classes).to(device)
model.load_state_dict(torch.load('./saved_models/model_arr_final.ckpt'))
# Test the model
# eval mode (batchnorm uses moving mean/var instead of mini-batch mean/var)
class_to_arr_vec_dict = {
0: [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
],
1: [
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
],
2: [
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
from model import SimpleNet, ResNet, ConvNet
from mcts import mcts
from agents import netAgent, processObservation
from epoch_training import selfplay, net_update
from evaluation import evaluate
model = ConvNet(42, 7, 64)
defaultModel = ConvNet(42, 7, 64)
log = open("log.txt", 'w')
# defaultModel.load_state_dict(torch.load('parameters_simple128.pth'))
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
for epoch in range(1000):
agent = netAgent(model, return_probs=True)
against = netAgent(defaultModel, incorrect_moves=False)
training_data = selfplay(agent, against, num=10)
net_update(model, training_data, optimizer)
agent = netAgent(model, incorrect_moves=False, best_move=False)
against = netAgent(defaultModel, incorrect_moves=False, best_move=False)
result = evaluate(agent, against, 1000)
log.write("Epoch " + str(epoch) + " Result: " + str(result) + "\n")
print("Test result: ", result)
if (result > 0.65):
torch.save(model.state_dict(), "parameters_simple128.pth")
defaultModel.load_state_dict(model.state_dict())
print("switch")
log.write("Switch\n")
def main(args):
best_acc1 = 0
os.makedirs('checkpoints', exist_ok=True)
args.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('device: {}'.format(args.device))
# create model
model = ConvNet(cfg.NUM_CLASSES).to(args.device)
#model.apply(weights_init_normal)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().to(args.device)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume, map_location=args.device)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
train_dataset = ImageFolder(cfg.TRAIN_PATH)
val_dataset = ImageFolder(cfg.VAL_PATH)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
logger = Logger('./logs')
for epoch in range(args.start_epoch, args.epochs):
# train for one epoch
adjust_learning_rate(optimizer, epoch, args)
train_loss, train_acc = train(train_loader, model, criterion,
optimizer, epoch, args)
# evaluate on validation set
val_loss, val_acc = validate(val_loader, model, criterion, args)
# remember best acc@1 and save checkpoint
is_best = val_acc > best_acc1
best_acc1 = max(val_acc, best_acc1)
# log
info = {
'train_loss': float(train_loss),
'train_acc': float(train_acc),
'val_loss': float(val_loss),
'val_acc': float(val_acc)
}
for tag, value in info.items():
logger.scalar_summary(tag, value, epoch)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best)
import torchvision.transforms as transforms
from model import ConvNet, Fully
from data import TestDataset
if __name__ == "__main__":
data_path, model_type, output = sys.argv[1], sys.argv[2], sys.argv[3]
if model_type == 'conv':
model = ConvNet()
elif model_type == 'fully':
model = Fully()
#######################################################################
# Modifiy this part to load your trained model
# TODO
model.load_state_dict(torch.load('./checkpoint/%s.pth' % model.name()))
#######################################################################
use_cuda = torch.cuda.is_available()
if use_cuda:
model.cuda()
model.eval()
# Load data
trans = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (1.0, ))
])
test_set = TestDataset(data_path, transform=trans)
print('Length of Testing Set:', len(test_set))
class Learner:
def __init__(self, args, q_batch):
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.q_batch = q_batch
self.learn_step_counter = 0
self.gamma = args.gamma
self.batch_size = args.batch_size
self.env = gym.make(args.env)
self.n_act = self.env.action_space.n
self.n_state = self.env.observation_space.shape[0]
self.n_atom = args.atom
self.v_min = args.v_min
self.v_max = args.v_max
self.dz = (self.v_max - self.v_min) / (self.n_atom - 1)
self.z = [self.v_min + i * self.dz for i in range(self.n_atom)]
self.z_space = torch.FloatTensor(self.z).to(self.device)
self.net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device)
self.target_net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device)
self.optimizer = optim.Adam(self.net.parameters(), lr=args.lr)
def learn(self):
while True:
self.learn_step_counter += 1
# target parameter update
if self.learn_step_counter % 10 == 0:
self.update_target()
states, actions, rewards, next_states, dones = self.q_batch.get(block=True)
states = torch.FloatTensor(states).to(self.device)
actions = torch.LongTensor(actions).to(self.device)
next_states = torch.FloatTensor(next_states).to(self.device)
dones = [int(i) for i in dones]
# action value distribution prediction
# (m, N_ACTIONS, N_ATOM)
curr_q = self.net(states)
# 実際に行動したQだけを取り出す
curr_q = torch.stack([curr_q[i].index_select(0, actions[i])
for i in range(self.batch_size)]).squeeze(1)
# get next state value
next_q = self.net(next_states).detach() # (m, N_ACTIONS, N_ATOM)
next_q = torch.sum(next_q * self.z_space.view(1, 1, -1), dim=2) # (m, N_ACTIONS)
next_action = next_q.argmax(dim=1) # (m)
# target_q
target_q = self.target_net(next_states).detach().cpu().numpy()
target_q = [target_q[i, action, :] for i, action in enumerate(next_action)]
target_q = np.array(target_q) # (m, N_ATOM)
m_prob = np.zeros((self.batch_size, self.n_atom)) # (m, N_ATOM)
# we didn't vectorize the computation of target assignment.
for i in range(self.batch_size):
for j in range(self.n_atom):
Tz = np.fmin(self.v_max,
np.fmax(self.v_min,
rewards[i]
+ (1 - dones[i]) * 0.99 * (self.v_min + j * self.dz)
)
)
bj = (Tz - self.v_min) / self.dz
lj = np.floor(bj).astype(int) # m_l
uj = np.ceil(bj).astype(int) # m_u
# calc prob mass of relative position weighted with distance
m_prob[i, lj] += (dones[i] + (1 - dones[i]) * target_q[i][j]) * (uj - bj)
m_prob[i, uj] += (dones[i] + (1 - dones[i]) * target_q[i][j]) * (bj - lj)
m_prob = m_prob / m_prob.sum(axis=1, keepdims=1)
m_prob = torch.FloatTensor(m_prob).to(self.device)
# print(curr_q)
# calc huber loss, dont reduce for importance weight
loss = - torch.mean(torch.sum(m_prob * torch.log(curr_q + 1e-20), dim=1)) # (m , N_ATOM)
if self.learn_step_counter % 100 == 0:
print('loss:', loss.item())
# backprop loss
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
def update_target(self):
self.target_net.load_state_dict(self.net.state_dict())
class Actor:
def __init__(self, args, actor_id, q_trace, learner):
self.seed = args.seed
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.q_trace = q_trace
self.learner = learner
self.env = gym.make(args.env)
self.env_state = self.env.reset()
self.n_act = self.env.action_space.n
self.n_state = self.env.observation_space.shape[0]
self.n_atom = args.atom
self.net = ConvNet(self.n_state, self.n_act, self.n_atom).to(self.device)
# パラメータ
self.v_min = args.v_min
self.v_max = args.v_max
self.dz = float(self.v_max - self.v_min) / (self.n_atom - 1)
self.z = [self.v_min + i * self.dz for i in range(self.n_atom)]
# self.z = np.linspace(self.v_min, self.v_max, self.n_atom)
self.value_range = torch.FloatTensor(self.z).to(self.device) # (N_ATOM)
self.step_num = args.step_num
self.eps_greedy = 0.4 ** (1 + actor_id * 7 / (args.n_actors - 1)) \
if args.n_actors > 1 else 0.4
self.n_episodes = 0
self.n_steps = 0
def performing(self):
# torch.manual_seed(self.seed)
while True:
self.load_model()
self.train_episode()
if self.n_episodes % 10 == 0:
rewards = self.evaluation(self.env)
rewards_mu = np.array([np.sum(np.array(l_i), 0) for l_i in rewards]).mean()
print("Episode %d, Average Reward %.2f"
% (self.n_episodes, rewards_mu))
def train_episode(self):
done = False
state = self.env.reset()
self.env_state = state
while not done:
self.n_steps += 1
action = self.choose_action(self.env_state)
next_state, reward, done, _ = self.env.step(action)
reward = 0
if done:
if self.n_steps > 195:
reward = 1
else:
reward = -1
# push memory
self.q_trace.put((state, action, reward, next_state, done),
block=True)
self.env_state = next_state
if done:
self.env_state = self.env.reset()
break
if done:
self.n_steps = 0
self.n_episodes += 1
self.episode_done = True
else:
self.episode_done = False
def choose_action(self, state):
if np.random.uniform() >= self.eps_greedy:
state = torch.FloatTensor(state).to(self.device).unsqueeze(0)
action_value_dist = self.net(state)
action_value = torch.sum(action_value_dist * self.value_range.view(1, 1, -1), dim=2)
action = torch.argmax(action_value, dim=1).data.cpu().numpy().item()
else:
action = np.random.randint(0, self.n_act)
return action
def evaluation(self, env_eval):
rewards = []
for i in range(10):
rewards_i = []
state = env_eval.reset()
action = self.action(state)
state, reward, done, _ = env_eval.step(action)
rewards_i.append(reward)
while not done:
action = self.action(state)
state, reward, done, _ = env_eval.step(action)
rewards_i.append(reward)
rewards.append(rewards_i)
return rewards
def action(self, state):
state = torch.FloatTensor([state]).to(self.device)
action_value_dist = self.net(state)
action_value = torch.sum(action_value_dist * self.value_range.view(1, 1, -1), dim=2)
action = torch.argmax(action_value, dim=1).data.cpu().numpy().item()
return action
def load_model(self):
try:
self.net.load_state_dict(self.learner.net.state_dict())
except:
print('load error')
class Learner:
def __init__(self, args, q_batch):
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
self.q_batch = q_batch
self.update_count = 0
self.gamma = args.gamma
self.batch_size = args.batch_size
self.env_eval = gym.make(args.env)
self.n_act = self.env_eval.action_space.n
self.n_state = self.env_eval.observation_space.shape[0]
self.n_quant = args.quant
self.target_net_update_freq = args.target_net_update_freq
self.net = ConvNet(self.n_state, self.n_act,
self.n_quant).to(self.device)
self.target_net = ConvNet(self.n_state, self.n_act,
self.n_quant).to(self.device)
self.optimizer = optim.Adam(self.net.parameters(), lr=args.lr)
def learn(self):
while True:
self.update_count += 1
if self.update_count % 10 == 0:
rewards = self.evaluation()
rewards_mu = np.array(
[np.sum(np.array(l_i), 0) for l_i in rewards]).mean()
print('update cnt %d Eval Reward %.2f' %
(self.update_count, rewards_mu))
# target parameter update
if self.update_count % self.target_net_update_freq == 0:
self.update_target()
states, actions, rewards, next_states, dones = self.q_batch.get(
block=True)
states = torch.FloatTensor(states).to(self.device)
actions = torch.LongTensor(actions).to(self.device)
next_states = torch.FloatTensor(next_states).to(self.device)
dones = np.array([int(i) for i in dones])
# action value distribution prediction
# [BATCH, N_QUANT, N_ACTIONS]
curr_q, tau = self.net(states)
# 実際に行動したQだけを取り出す
# [BATCH, N_QUANT, 1]
curr_q = torch.stack([
curr_q[i].index_select(1, actions[i])
for i in range(self.batch_size)
])
# # [BATCH, N_QUANT, N_QUANT]
curr_q = curr_q.repeat(1, 1, self.n_quant)
# get next state value
# [BATCH, N_QUANT, N_ACTIONS]
next_q, _ = self.net(next_states)
next_action = next_q.sum(dim=1).argmax(dim=1)
# target_q
with torch.no_grad():
# [BATCH, N_QUANT, N_ACT]
target_q, _ = self.target_net(next_states)
target_q = target_q.detach().cpu().numpy()
# [BATCH, N_QUANT, 1]
target_q = np.array([
target_q[i, :, action]
for i, action in enumerate(next_action)
])
target_q = rewards.reshape(
-1, 1) + self.gamma * target_q * (1 - dones.reshape(-1, 1))
target_q = torch.FloatTensor(target_q).to(
self.device).unsqueeze(2)
# # [BATCH, N_QUANT, N_QUANT]
target_q = target_q.repeat(1, 1, self.n_quant)
target_q = target_q.permute(0, 2, 1)
# loss = F.smooth_l1_loss(curr_q, target_q.detach(), reduction='none')
# (BATCH, N_QUANT, N_QUANT)
tau = tau.repeat(1, 1, self.n_quant)
diff = target_q - curr_q
loss = self.huber(diff)
I_delta = (diff < 0).double()
loss *= torch.abs(tau - I_delta)
# huber loss
loss = torch.mean(torch.sum(torch.mean(loss, dim=2), dim=1))
# backprop loss
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
def huber(self, x):
cond = (x.abs() < 1.0).float().detach()
return 0.5 * x.pow(2) * cond + (x.abs() - 0.5) * (1.0 - cond)
def update_target(self):
self.target_net.load_state_dict(self.net.state_dict())
def evaluation(self):
rewards = []
for _ in range(10):
rewards_i = []
state = self.env_eval.reset()
action = self.action(state)
state, reward, done, _ = self.env_eval.step(action)
rewards_i.append(reward)
while not done:
action = self.action(state)
state, reward, done, _ = self.env_eval.step(action)
rewards_i.append(reward)
rewards.append(rewards_i)
return rewards
def action(self, state):
state = torch.FloatTensor(state).to(self.device).unsqueeze(0)
action_value, _ = self.net(state)
# if self.update_count > 3000:
# dist_action = action_value[0].detach().cpu().numpy()
# sns.distplot(dist_action[:, 0], bins=10, color='red')
# sns.distplot(dist_action[:, 1], bins=10, color='blue')
# plt.show()
action_value = action_value[0].sum(dim=0)
action = torch.argmax(action_value).detach().cpu().item()
return action
class Actor:
def __init__(self, args, actor_id, q_trace, learner):
self.actor_id = actor_id
self.seed = args.seed
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.q_trace = q_trace
self.learner = learner
self.env = gym.make(args.env)
self.env_state = self.env.reset()
self.n_act = self.env.action_space.n
self.n_state = self.env.observation_space.shape[0]
self.n_quant = args.quant
self.net = ConvNet(self.n_state, self.n_act, self.n_quant).to(self.device)
self.eps_greedy = 0.4 ** (1 + actor_id * 7 / (args.n_actors - 1)) \
if args.n_actors > 1 else 0.4
self.n_episodes = 0
self.n_steps = 0
def performing(self):
torch.manual_seed(self.seed)
while True:
self.load_model()
self.train_episode()
def train_episode(self):
self.n_episodes += 1
done = False
self.env_state = self.env.reset()
while not done:
self.n_steps += 1
action = self.choose_action(self.env_state)
next_state, reward, done, _ = self.env.step(action)
# reward = 0
# if done:
# reward = -1
# if self.n_steps > 190:
# reward = 1
# push memory
self.q_trace.put((self.env_state, action, reward, next_state, done),
block=True)
self.env_state = next_state
if done:
print(' '*30, 'Actor:', self.actor_id,
'Episode:', self.n_episodes, ' steps:', self.n_steps)
self.n_steps = 0
def choose_action(self, state):
if np.random.uniform() >= self.eps_greedy:
state = torch.FloatTensor(state).to(self.device).unsqueeze(0)
action_value, _ = self.net(state)
action_value = action_value[0].sum(dim=0)
action = torch.argmax(action_value).detach().cpu().item()
else:
action = np.random.randint(0, self.n_act)
return action
def load_model(self):
try:
self.net.load_state_dict(self.learner.net.state_dict())
except:
print('load error')
def train(pre_trained=None):
# create folder to save models and loss graphs
reference = hp['net_type'] + str(time.strftime("_%Y%m%d_%H%M%S"))
checkpoints_folder = hp["output_dir"] + '/checkpoints/' + reference
os.makedirs(checkpoints_folder, exist_ok=True)
# save hyper parameter settings
pickle_file_location = checkpoints_folder + "/hp.pkl"
pickle_file = open(pickle_file_location, "wb")
pickle.dump(hp, pickle_file)
pickle_file.close()
# create data iterator
train_data_set = DataGenerator(hp)
iterator = DataLoader(dataset=train_data_set,
batch_size=hp['batch_size'],
num_workers=hp['num_workers'],
pin_memory=True,
shuffle=False,
drop_last=True)
val_set = ValidationDataGenerator(hp)
val_set_iterator = DataLoader(dataset=val_set,
batch_size=50,
num_workers=hp['num_workers'],
pin_memory=True,
shuffle=False,
drop_last=True)
# create model and loss
model = ConvNet().to(device)
loss = CrossEntropyLoss().to(device)
# optimizer
optimizer = torch.optim.Adam(params=model.parameters(),
lr=hp['learning_rate'])
start_epoch = 0
# load pre trained model
if pre_trained is not None:
ckpt = torch.load(pre_trained)
model.load_state_dict(ckpt['net'])
optimizer.load_state_dict(ckpt['opt'])
start_epoch = ckpt['epoch'] + 1
# init loss arrays
classification_loss = np.zeros(hp['num_epochs'])
train_accuracy = np.zeros(hp['num_epochs'])
val_accuracy = np.zeros(hp['num_epochs'])
# training loop
for epoch in range(start_epoch, hp['num_epochs']):
c_loss = 0
acc = 0
for i, (img, label) in enumerate(iterator):
img = img.to(device, dtype=torch.float)
label = label.to(device, dtype=torch.float)
optimizer.zero_grad()
logits = model(img)
l = loss(logits, label.long())
l.backward()
optimizer.step()
c_loss += l.item()
# calc accuracy
logits = logits.detach().cpu().numpy()
label = label.detach().cpu().numpy()
acc += utils.classification_accuracy(logits, label)
print("epoch = {}, Training_sample={}, classification loss ={}".
format(epoch, i, l.item()))
# average loss per epoch
classification_loss[epoch] = c_loss / (i + 1)
# average accuracy per epoch
train_accuracy[epoch] = acc / (i + 1)
print("epoch = {}, average classification loss ={}".format(
epoch, classification_loss[epoch]))
print("epoch = {}, Training accuracy ={}".format(
epoch, train_accuracy[epoch]))
with torch.no_grad():
val_acc = 0
for i, (img, label) in enumerate(val_set_iterator):
img = img.to(device, dtype=torch.float)
label = label.to(device, dtype=torch.float)
logits = model(img)
# calc accuracy
logits = logits.detach().cpu().numpy()
label = label.detach().cpu().numpy()
val_acc += utils.classification_accuracy(logits, label)
val_accuracy[epoch] = val_acc / (i + 1)
print("epoch = {}, Validation set accuracy ={}".format(
epoch, val_accuracy[epoch]))
# plot accuracy curves and save model
plt.plot(range(1,
len(train_accuracy) + 1),
train_accuracy,
'b-',
label=" Train Accuracy")
plt.plot(range(1,
len(val_accuracy) + 1),
val_accuracy,
'r-',
label="Validation Accuracy")
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.legend(loc='best')
plt.savefig(checkpoints_folder + "/accuracy.jpeg", bbox_inches="tight")
plt.clf()
net_save = {
'net': model.state_dict(),
'opt': optimizer.state_dict(),
'epoch': epoch
}
torch.save(
net_save, checkpoints_folder +
"/convnet_ethiopian_mnist_epoch{}.pth".format(epoch))
# coding:utf-8
import numpy as np
import torch
import torchvision.transforms as transforms
from model import ConvNet
from PIL import Image
model_path = "./model.ckpt"
img_path = "./12.png"
model = ConvNet()
print "load pretrained model from %s" % model_path
model.load_state_dict(torch.load(model_path))
transformer = transforms.ToTensor()
image = Image.open(img_path).convert('L')
#image.resize((28, 28), Image.BILINEAR)
image = transformer(image)
image = image.view(1, *image.size())
model.eval()
output = model(image)
preds = torch.max(output, 1)[1]
print preds.item()
import cv2
import torch
from torchsummary import summary
from torchvision.transforms import ToTensor
import numpy as np
from tensorboardX import SummaryWriter
from model import ConvNet
from widerface import WIDERFaceDetection
from augmentations import SSDAugmentation
if __name__ == "__main__":
net = ConvNet()
net.load_state_dict(torch.load('no_gassuion_epoch240.pth'))
net = net.eval()
if torch.cuda.is_available():
net = net.cuda()
summary(net.cuda(), input_size=(3, 640, 640), batch_size=1, device='cuda')
WIDERFace_ROOT = r"F:\Datasets\人脸识别\WIDERFACE"
dataset = WIDERFaceDetection(WIDERFace_ROOT)
writer = SummaryWriter('eval_log')
# img = dataset.pull_image(1144)
img = cv2.imread('2.jpg')
# cv2.waitKey()
# _, img = cv2.VideoCapture(0).read()
# img = cv2.resize(img, (640, 640))
src = img.copy()
img = ToTensor()(img).unsqueeze(0)
import torch
import numpy as np
from sklearn import metrics
import matplotlib.pyplot as plt
from data import TwoClassCifar10
from model import ConvNet, LogisticRegression
from config import Config as config
test_dataset = TwoClassCifar10(config.root, train=False)
conv_net = ConvNet(config.input_channel, 2)
lr_model = LogisticRegression(config.cifar10_input_size)
conv_net.load_state_dict(torch.load("model/2020428163925_0.719000.pth"))
lr_model.load_state_dict(torch.load("model/2020428163951_0.589000.pth"))
conv_preds = []
lr_preds = []
targets = []
with torch.no_grad():
for image, label in test_dataset:
image.unsqueeze_(0)
conv_pred = conv_net(image)
lr_pred = lr_model(image)
conv_pred = torch.max(torch.softmax(conv_pred, dim=1),
dim=1)[0].squeeze()
lr_pred = torch.sigmoid(lr_pred).squeeze()
conv_preds.append(conv_pred.item())
lr_preds.append(lr_pred.item())
targets.append(label)
fpr, tpr, thresholds = metrics.roc_curve(targets, conv_preds)
from model import ConvNet
# Load in serialized model, config, and scaler
with open("config.json", "r") as f:
CONFIG = json.load(f)
time_steps = CONFIG["timesteps"]
with open("scaler.pck", "rb") as f:
scaler = pickle.load(f)
ensemble = []
for s in [2, 3, 5, 7, 11, 13, 17]:
for pwr in [1.5, 2.4, 2.5]:
model = ConvNet(CONFIG['n_feat'], CONFIG['n_filters'], 2, CONFIG['dropout'])
model.load_state_dict(torch.load('conv_{:d}_{:.1f}'.format(s, pwr)))
model.eval()
ensemble.append(model)
# THIS MUST BE DEFINED FOR YOUR SUBMISSION TO RUN
def predict_dst(
solar_wind_7d: pd.DataFrame,
satellite_positions_7d: pd.DataFrame,
latest_sunspot_number: float,
) -> Tuple[float, float]:
"""
Take all of the data up until time t-1, and then make predictions for
times t and t+1.
Parameters
----------
solar_wind_7d: pd.DataFrame
def pred_prob(arg_path, field_path, pth_path, doc, device=torch.device('cpu')):
# Load args
# with open(arg_path) as f:
# args = json.load(f)['args']
arg_path = os.path.join(
'https://raw.githubusercontent.com/qianyingw/rob-pome/master/rob-app',
arg_path)
with urllib.request.urlopen(arg_path) as url:
args = json.loads(url.read().decode())['args']
# Load TEXT field
field_url = os.path.join(
'https://github.com/qianyingw/rob-pome/raw/master/rob-app', field_path)
field_path = wget.download(field_url)
with open(field_path, "rb") as fin:
TEXT = dill.load(fin)
os.remove(field_path)
unk_idx = TEXT.vocab.stoi[TEXT.unk_token] # 0
pad_idx = TEXT.vocab.stoi[TEXT.pad_token] # 1
# Load model
if args['net_type'] == 'cnn':
sizes = args['filter_sizes'].split(',')
sizes = [int(s) for s in sizes]
model = ConvNet(vocab_size=args['max_vocab_size'] + 2,
embedding_dim=args['embed_dim'],
n_filters=args['num_filters'],
filter_sizes=sizes,
output_dim=2,
dropout=args['dropout'],
pad_idx=pad_idx,
embed_trainable=args['embed_trainable'],
batch_norm=args['batch_norm'])
if args['net_type'] == 'attn':
model = AttnNet(vocab_size=args['max_vocab_size'] + 2,
embedding_dim=args['embed_dim'],
rnn_hidden_dim=args['rnn_hidden_dim'],
rnn_num_layers=args['rnn_num_layers'],
output_dim=2,
bidirection=args['bidirection'],
rnn_cell_type=args['rnn_cell_type'],
dropout=args['dropout'],
pad_idx=pad_idx,
embed_trainable=args['embed_trainable'],
batch_norm=args['batch_norm'],
output_attn=False)
# Load checkpoint
pth_url = os.path.join(
'https://github.com/qianyingw/rob-pome/raw/master/rob-app', pth_path)
pth_path = wget.download(pth_url)
checkpoint = torch.load(pth_path, map_location=device)
os.remove(pth_path)
state_dict = checkpoint['state_dict']
model.load_state_dict(state_dict, strict=False)
model.cpu()
# Load pre-trained embedding
pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
model.embedding.weight.data[unk_idx] = torch.zeros(
args['embed_dim']) # Zero the initial weights for <unk> tokens
model.embedding.weight.data[pad_idx] = torch.zeros(
args['embed_dim']) # Zero the initial weights for <pad> tokens
# Tokenization
tokens = [tok.text.lower() for tok in nlp.tokenizer(doc)]
idx = [TEXT.vocab.stoi[t] for t in tokens]
while len(idx) < args['max_token_len']:
idx = idx + [1] * args['max_token_len']
if len(idx) > args['max_token_len']:
idx = idx[:args['max_token_len']]
# Prediction
model.eval()
doc_tensor = torch.LongTensor(idx).to(device)
doc_tensor = doc_tensor.unsqueeze(
1) # bec AttnNet input shape is [seq_len, batch_size]
probs = model(doc_tensor)
probs = probs.data.cpu().numpy()[0]
# print("Prob of RoB reported: {:.4f}".format(probs[1]))
return probs[1]
class Wrapper(object):
"""docstring for Wrapper."""
def __init__(self, config, cont=None):
super(Wrapper, self).__init__()
with open(config, 'r') as f:
config = json.load(f)
self.config = config
self.best_path = str(self.config['model']['model_save_path'] +
self.config['name'] + '_model_best.pt')
self.model = ConvNet(config['model'])
self.continuing = False
if cont is not None:
print('loading in weights')
self.load_model(cont)
self.continuing = True
self.cuda = torch.cuda.is_available()
if self.cuda:
print('using cuda')
self.model.cuda()
def train(self):
model = self.model
config = self.config
trainloader = DataLoader(
KanjiDataset(self.config, train=True),
batch_size=config['train']['batch_size'], shuffle=True, pin_memory=True)
# self.valloader = DataLoader(
# KanjiDataset(self.config, train=False),
# batch_size=config['train']['batch_size'], pin_memory=True)
self.valset = KanjiDataset(self.config, train=False)
objective = nn.CrossEntropyLoss()
self.objective = objective
optimizer = optim.Adam(model.parameters(), lr=config['train']['learning_rate'])
# bestloss = float('Inf') if not self.continuing else self.valid()
bestacc = 0.0 if not self.continuing else self.eval()[0]
past_best = 0
max_past = 50
for e in range(config['train']['epochs']):
avgloss = 0.0
for i, (x, y) in enumerate(trainloader):
if self.cuda:
x = x.cuda(async=True)
y = y.cuda(async=True)
optimizer.zero_grad()
preds = model(x)
loss = objective(preds, y)
avgloss += loss.item()
loss.backward()
optimizer.step()
preds = None
gc.collect()
avgloss /= len(trainloader)
# vloss = self.valid()
vacc = self.eval()[0]
if e%5==0:
print('epoch: {}, loss: {:.4f}, val_acc: {:.4f}'
.format( e+1, avgloss, vacc ) )
# print('epoch: {}, loss: {:.4f}, val_loss: {:.4f}, memory: {:.4f}'
# .format(e+1, avgloss, vloss, torch.cuda.memory_allocated(0) / 1e9 ) )
# if e%20==0:
# self.print_acc()
# if vloss < bestloss:
if vacc > bestacc:
path = str(self.config['model']['model_save_path'] +
self.config['name'] + '_model_{:.4f}.pt'.format(vacc))
self.save_model(path)
self.save_model(self.best_path)
# bestloss = vloss
bestacc = vacc
past_best = 0
else:
past_best += 1
if past_best >= max_past:
print('past')
break
self.valloader = None
self.print_acc()
return
def valid(self):
loss = 0.0
for (x, y) in self.valloader:
if self.cuda:
x = x.cuda(async=True)
y = y.cuda(async=True)
loss += self.objective(self.model(x), y).item()
return loss/len(self.valloader)
def eval(self, train=False):
validset = self.valset if train else KanjiDataset(self.config, train=False)
acc = 0
conf = np.zeros((self.config['model']['classes'],
self.config['model']['classes']), dtype=np.int32)
for (x, y) in validset:
pred = self.predict(x)
acc += (pred == y)
conf[y, pred] = conf[y, pred] + 1
return acc/len(validset), conf
def print_acc(self):
acc, conf = self.eval()
print('acc:', acc)
print('conf:\n', conf)
def predict(self, image):
image = torch.unsqueeze(image, 0)
if self.cuda:
image = image.cuda(async=True)
pred = self.model(image)
pred = torch.argmax(pred[0])
return pred.item()
def save_model(self, path):
torch.save( self.model.state_dict(), path )
print('save:', path)
def load_model(self, cont):
path = self.best_path
if cont != 'cont':
path = join(self.config['model']['model_save_path'], cont)
print('loading path:', path)
self.model.load_state_dict( torch.load( path ) )
