def test():
# setting model
model = Net() # 实例化一个网络
model.cuda() # 送入GPU，利用GPU计算
model = nn.DataParallel(model)
model.load_state_dict(torch.load(model_file)) # 加载训练好的模型参数
model.eval() # 设定为评估模式，即计算过程中不要dropout
# get data
files = random.sample(os.listdir(dataset_dir), N) # 随机获取N个测试图像
imgs = [] # img
imgs_data = [] # img data
for file in files:
img = Image.open(dataset_dir + file) # 打开图像
img_data = getdata.dataTransform(img) # 转换成torch tensor数据
imgs.append(img) # 图像list
imgs_data.append(img_data) # tensor list
imgs_data = torch.stack(imgs_data) # tensor list合成一个4D tensor
# calculation
out = model(imgs_data) # 对每个图像进行网络计算
out = F.softmax(out, dim=1) # 输出概率化
out = out.data.cpu().numpy() # 转成numpy数据
# pring results 显示结果
for idx in range(N):
plt.figure()
if out[idx, 0] > out[idx, 1]:
plt.suptitle('cat:{:.1%},dog:{:.1%}'.format(out[idx, 0], out[idx, 1]))
else:
plt.suptitle('dog:{:.1%},cat:{:.1%}'.format(out[idx, 1], out[idx, 0]))
plt.imshow(imgs[idx])
plt.show()
def test():
model = Net() # 实例化一个网络
model.cuda() # 送入GPU，利用GPU计算
model.load_state_dict(torch.load(model_file)) # 加载训练好的模型参数
model.eval() # 设定为评估模式，即计算过程中不要dropout
datafile = DVCD('test', dataset_dir) # 实例化一个数据集
print('Dataset loaded! length of train set is {0}'.format(len(datafile)))
index = np.random.randint(0, datafile.data_size,
1)[0] # 获取一个随机数，即随机从数据集中获取一个测试图片
img = datafile.__getitem__(index) # 获取一个图像
img = img.unsqueeze(
0) # 因为网络的输入是一个4维Tensor，3维数据，1维样本大小，所以直接获取的图像数据需要增加1个维度
img = Variable(img).cuda() # 将数据放置在PyTorch的Variable节点中，并送入GPU中作为网络计算起点
out = model(img) # 网路前向计算，输出图片属于猫或狗的概率，第一列维猫的概率，第二列为狗的概率
print(out) # 输出该图像属于猫或狗的概率
if out[0, 0] > out[0, 1]: # 猫的概率大于狗
print('the image is a cat')
else: # 猫的概率小于狗
print('the image is a dog')
img = Image.open(datafile.list_img[index]) # 打开测试的图片
plt.figure('image') # 利用matplotlib库显示图片
plt.imshow(img)
plt.show()
def test():
model = Net() #네트워크실제화
model.cuda() # GPU로 계산
model.load_state_dict(torch.load(model_file)) # 학습된 모델 로딩
model.eval() # eval모델
datafile = DVCD('test', dataset_dir) # dataset 실례화
print('Dataset loaded! length of train set is {0}'.format(len(datafile)))
index = np.random.randint(0, datafile.data_size, 1)[0] # random수로 image를 임의 선택함
img = datafile.__getitem__(index) # image 하다 받다
img = img.unsqueeze(0)
img = Variable(img).cuda() # Data를 PyTorch의 Variable노드에서 놓고 ,또는 GPU에서 들어가고 시작점을 담임힘.
out = model(img)
out = F.softmax(out, dim=1) # SoftMax으로 2个개 output값을 [0.0, 1.0]을 시키다,합이1이다.
print(out) # output는 개/고양이의 확률
if out[0, 0] > out[0, 1]: # 개<고양이
print('the image is a cat')
else: # 개>고양이
print('the image is a dog')
img = Image.open(datafile.list_img[index]) # text image open
plt.figure('image') # matplotlib로 image show
plt.imshow(img)
plt.show()
def eval():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
np.random.seed(seed=46)
model = Net()
path = 'model.pth.tar'
checkpoint = torch.load(path, map_location=torch.device('cpu'))
model.load_state_dict(checkpoint)
model = model.to(device)
model.eval()
ious = []
for _ in tqdm(range(1000)):
img, label = make_data()
img = torch.from_numpy(np.asarray(img, dtype=np.float32))
img = torch.unsqueeze(img, 0)
img = torch.unsqueeze(img, 0)
img = img.to(device)
pred = model.predict(img)
ious.append(score_iou(label, pred))
ious = np.asarray(ious, dtype="float")
ious = ious[~np.isnan(ious)] # remove true negatives
print((ious > 0.7).mean())
def test():
model_file = model_path + 'model.pth'
model = Net()
model.cuda()
model = nn.DataParallel(model)
model.load_state_dict(torch.load(model_file))
model.eval()
files = os.listdir(dataset_dir)
imgs_data = []
out1 = []
for file in files:
img = Image.open(dataset_dir + file)
img_data = getdata.dataTransform(img)
imgs_data.append(img_data)
imgs_data = torch.stack(imgs_data)
out = model(imgs_data)
out = F.softmax(out, dim=1)
out = out.data.cpu().numpy()
out2 = out[0]
out1.append(out2)
imgs_data = []
out3 = np.array(out1)
x = []
y = []
for idx in range(len(files)):
a = files[idx]
(filename, extension) = os.path.splitext(a)
b = int(filename)
if b <= 900:
y.append(1)
if out3[idx, 0] > out3[idx, 1]:
x.append(1)
else:
x.append(0)
else:
y.append(0)
if out3[idx, 0] > out3[idx, 1]:
x.append(1)
else:
x.append(0)
p = metrics.precision_score(y, x)
r = metrics.recall_score(y, x)
f1 = metrics.f1_score(y, x)
print('-------------test-----------------')
print('precision: %f' % p)
print('recall: %f' % r)
print('f1_score: %f' % f1)
def find_circle(img):
model = Net()
checkpoint = torch.load('model.pth.tar')
model.load_state_dict(checkpoint)
model.eval()
with torch.no_grad():
image = np.expand_dims(np.asarray(img), axis=0)
image = torch.from_numpy(np.array(image, dtype=np.float32))
normalize = transforms.Normalize(mean=[0.5], std=[0.5])
image = normalize(image)
image = image.unsqueeze(0)
output = model(image)
return [round(i) for i in (200 * output).tolist()[0]]
def cvt_model(pickle_model, script_model):
print("start convert")
checkpoint = torch.load(pickle_model)
net = Net()
net.load_state_dict(checkpoint['model_state_dict'])
#net.cuda()
net.eval() # must be call
#example = torch.rand(1,3,32,32).cuda()
example = torch.rand(1,3,32,32).cpu()
traced_script_module = torch.jit.trace(net, example)
traced_script_module.save(script_model)
print("convert complete")
def inference(time_series_data, start_date, model_path='./model_best.pth', save_output=False):
data_channels = 2
input_time_interval = 365
output_time_interval = 7
predict_date_start = start_date
predict_date_end = predict_date_start + datetime.timedelta(days=output_time_interval - 1)
input_date_start = predict_date_start - datetime.timedelta(days=input_time_interval)
input_date_end = predict_date_start - datetime.timedelta(days=1)
input = time_series_data[input_date_start:input_date_end].values.transpose(1, 0)
input = input.reshape((1, data_channels, input_time_interval)).astype(np.float)
target = time_series_data[predict_date_start:predict_date_end]['peak_load'].values
net = Net(in_ch=data_channels, out_ch=output_time_interval)
checkpoint = torch.load(model_path)
net.load_state_dict(checkpoint['net'])
net.eval()
torch.set_grad_enabled(False)
input = torch.tensor(input, dtype=torch.float)
output = net(input).detach().numpy()
print('input: {} ~ {}, output: {} ~ {}'.format(input_date_start.isoformat(), input_date_end.isoformat(),
predict_date_start.isoformat(), predict_date_end.isoformat()))
print('output: ', list(map('{:.0f}'.format, output[0])))
if len(target) == output_time_interval:
target = target.reshape((1, output_time_interval)).astype(np.float)
score = rmse(target, output)
print('target: ', list(map('{:.0f}'.format, target[0])))
print('RMSE: {}'.format(score))
if save_output:
date_list = [(start_date + datetime.timedelta(days=x)).strftime('%Y%m%d') for x in range(0, 7)]
df_dict = {
'date': date_list,
'peak_load(MW)': np.around(output[0]).astype(np.int)
}
df = pd.DataFrame(df_dict)
df.to_csv('submission.csv', encoding='UTF-8', index=0)
def main():
model = Net()
model.load_state_dict(torch.load("perfume_cnn.pt"))
model.eval()
summary(model, (3, 64, 64))
path_list = glob.glob("who_is_this_member/*")
print("path_list: {}".format(path_list))
out_dir = "./her_name_is"
if not os.path.exists(out_dir):
os.makedirs(out_dir)
for path in path_list:
image_name = path.split("/")[-1]
who = detect_who(path, model)
save_path = os.path.join(out_dir + "/" + image_name)
cv2.imwrite(save_path, who)
def test(mid_model_name):
print("=================================================")
print("test model:", mid_model_name)
checkpoint = torch.load(mid_model_name)
net = Net()
net.load_state_dict(checkpoint['model_state_dict'])
net.eval() # must be call
dataiter = iter(testloader)
images, labels = dataiter.next()
print(len(images), type(images[0]))
torchvision.utils.save_image(images[0], "test_image.bmp")
# file = open("xxx.dat", "w")
# for c in range(3):
# for h in range(32):
# for w in range(32):
# #print(images[0][c][h][w])
# file.write(str(float(images[0][c][h][w])) + ",")
# file.write("\n")
# file.close()
outputs = net(images)
# imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ',
' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))
prob, predicted = torch.max(outputs, 1)
print('Predicted: ',
' '.join('%5s' % classes[predicted[j]] for j in range(batch_size)))
print('Predicted: ',
' '.join('%2.2f' % prob[j] for j in range(batch_size)))
def test_local_bmp(mid_model_name):
print("=================================================")
print("test model:", mid_model_name)
checkpoint = torch.load(mid_model_name)
net = Net()
net.load_state_dict(checkpoint['model_state_dict'])
net.eval() # must be call
images = get_local_image()
outputs = net(images)
# imshow(torchvision.utils.make_grid(images))
# print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))
prob, predicted = torch.max(outputs, 1)
print('Predicted: ',
' '.join('%5s' % classes[predicted[j]] for j in range(batch_size)))
print('Predicted: ',
' '.join('%2.2f' % prob[j] for j in range(batch_size)))
# T[0] because currently using only 1 thread for environment
if args.model_based is not "None":
T[0].append((
state, action,
reward)) # append the state, action and reward into trajectory
done_bool = float(
done) if episode_timesteps < env._max_episode_steps else 0
# Store data in replay buffer
replay_buffer.add(state, action, next_state, reward, done_bool)
if args.model_based == "forward" or args.model_based == "dual":
# add imagined trajectories from fwd model into fwd_model_replay_buffer
if first_update: # model has been updated atleast once
forward_dynamics_model.eval() # model has a dropout layer !
t_s, t_a, t_ns, t_r, t_nd = _duplicate_batch_wise(state, args.model_iters, device, True), \
_duplicate_batch_wise(action, args.model_iters, device, True), \
_duplicate_batch_wise(next_state, args.model_iters, device, True), \
_duplicate_batch_wise(reward, args.model_iters, device, True), \
_duplicate_batch_wise(done, args.model_iters, device, True)
t_s = t_s.cpu().numpy()
t_a = t_a.cpu().numpy()
for _ in range(args.imagination_depth):
# add noise to actions and predict
t_a = (
t_a +
np.random.normal(0, max_action * args.expl_noise / 10,
def predict():
#------Settings---------------------------
weights = "./full_epoch_final.pth"
device = True
#-----------------------------------------
#------ Use GPU computation
# gpuInfo = GPUInfo()
# if device and not pt.cuda.is_available():
# raise Exception("No GPU found, please run without --cuda")
# else:
# GPU = gpuInfo.getGPUs()
# if device:
# pt.cuda.set_device(GPU)
# print("")
# print("Using --> GPU:{}".format(pt.cuda.current_device()))
# else:
# print("Using --> CPU")
#device = pt.device("cuda:0" if device else "cpu")
#------ Use CPU computation
device = pt.device("cpu")
print("Open File")
f = h5py.File('../../../thz-dataset/MetalPCB_446x446x91.mat', 'r')
d = f.keys()
dset = f['data_complex_roi']
x, y, z = dset.shape
params = np.ndarray(shape=(x, y, countParam), dtype=float)
params2 = np.ndarray(shape=(x, y, countParam), dtype=float)
curves = np.ndarray(shape=(x, y, valuesCurve), dtype=complex)
curvesPred = np.ndarray(shape=(x, y, valuesCurve), dtype=complex)
print("Network setup:\n")
net = Net()
#------ save model weight
matfiledata = {}
for name, param in net.named_parameters():
matfiledata[name.replace('.', '_')] = param.detach().numpy()
hdf5storage.write(matfiledata, '.', 'Model.mat', matlab_compatible=True)
# Load trained CNN weights
print("\nLoading trained parameters from '%s'..." % weights)
net = pt.load(weights, map_location=lambda storage, loc: storage)
net = net.to(device)
net = net.eval()
print("Done!")
learnedEpochs = weights.split('_')[-1]
learnedEpochs = learnedEpochs.split('.')[0]
predict_curve_time = time.time()
t2 = 0
FileContent = "y,StartTime,EndTime\n"
print("y,StartTime,EndTime")
for i in range(y):
curveData = dset[0:x, i, 0:z]
curveData = curveData['real'] + 1j * curveData['imag']
t1 = time.time()
curves[0:x, i, 0:z] = curveData
curve = np.ndarray(shape=(len(curveData[:,
0]), len(curveData[0, :]), 2),
dtype=float)
curve[:, :, 0] = curveData.real
curve[:, :, 1] = curveData.imag
curve = pt.from_numpy(curve)
curve = curve.float().permute(0, 2, 1)
curve = curve.unsqueeze(3).unsqueeze(3)
start_time = datetime.now()
y_predict = net(curve.to(device))
end_time = datetime.now()
elapsed_time = end_time - start_time
start_tstr = start_time.strftime("%Y/%m/%d:%H:%M:%S.%f")
end_tstr = end_time.strftime("%Y/%m/%d:%H:%M:%S.%f")
t2 = t2 + (time.time() - t1)
output_line = "{0}, {1}, {2}".format(str(i + 1), start_tstr, end_tstr)
print(output_line)
FileContent = FileContent + output_line + "\n"
params[:, i, :] = scaleUpAll(y_predict, False, device).cpu().detach()
params2[:, i, :] = y_predict.cpu().detach()
for i in range(x):
for j in range(y):
curvesPred[i, j, :] = math.fabs(
params2[i, j, 3]) * normAFactor * np.sinc(
params2[i, j, 0] * (normZ - params2[i, j, 1])) * np.exp(
-1j *
(normOmega * normZ - 2 * np.pi * params2[i, j, 2]))
print(time.strftime("Finish at: %H:%M:%S", time.gmtime(time.time())))
print(time.strftime("Inference Time:\t %H:%M:%S", time.gmtime(t2)))
print(
time.strftime("Overall Time:\t %H:%M:%S",
time.gmtime(time.time() - predict_curve_time)))
epochFile = open("predict_measure_result.txt", "w")
epochFile.write(FileContent)
epochFile.close()
print("Writing mat File")
matfiledata = {} # make a dictionary to store the MAT data in
matfiledata[u'A'] = params[:, :, 3]
matfiledata[u'Sigma'] = params[:, :, 0]
matfiledata[u'Mu'] = params[:, :, 1]
matfiledata[u'Phi'] = params[:, :, 2]
matfiledata[u'curvesIn'] = curves
matfiledata[u'curvesOut'] = curvesPred
matfiledata[u'rmse'] = np.mean(
np.power((curves.real - curvesPred.real), 2) +
np.power((curves.imag - curvesPred.imag), 2))
outputName = 'OutputMeasure_' + learnedEpochs + '.mat'
hdf5storage.write(matfiledata, '.', outputName, matlab_compatible=True)
print("Done")
d = euclidean(query_feature, features_dict["features"][i])
results.append((d, i))
results = sorted(results)[:top_k]
return results
train_dataset = datasets.MNIST(root='./mnist/',
train=True,
transform=transforms.ToTensor())
test_dataset = datasets.MNIST(root='./mnist/',
train=False,
transform=transforms.ToTensor())
test_loader = Data.DataLoader(dataset=test_dataset, batch_size=1, shuffle=True)
feature_dict = pickle.loads(open("./data/features_dict.pickle", "rb").read())
model = Net()
model.eval()
model.load_state_dict(
torch.load("./data/model.pth",
map_location=torch.device(
"cuda" if torch.cuda.is_available() else "cpu")))
encoder = model.encoder
for i, (img, lab) in enumerate(test_loader):
query_feature = encoder(img)
res = search(query_feature, feature_dict)
images = []
for (d, j) in res:
image = train_dataset.train_data[j, ...]
image = np.dstack([image] * 3)
images.append(image)
query = img.squeeze(0).permute(1, 2, 0)
class MyModel:
def __init__(self, trained_weights: str, device: str):
self.net = Net()
self.weights = trained_weights
self.device = torch.device('cuda:0' if device == 'cuda' else 'cpu')
#self.preprocess = transforms.Compose([
#transforms.Resize((300, 300)),
#transforms.ToTensor(),
#transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),])
self._initialize()
def _initialize(self):
# Load weights
try:
# Force loading on CPU if there is no GPU
if (torch.cuda.is_available() == False):
self.net.load_state_dict(
torch.load(self.weights,
map_location=lambda storage, loc: storage)
["state_dict"])
else:
self.net.load_state_dict(
torch.load(self.weights)["state_dict"])
except IOError:
print("Error Loading Weights")
return None
self.net.eval()
# Move to specified device
self.net.to(self.device)
#def predict(self,path):
# Open the Image and resize
#img = Image.open(path)
# Convert to tensor on device
#with torch.no_grad():
#img_tensor = self.preprocess(img) # tensor in [0,1]
#img_tensor = 1 - img_tensor
#xb = to_device(img_tensor.unsqueeze(0), self.device) #mg_tensor = img_tensor.view(1, 28, 28, 1).to(self.device)
# Do Inference
#yb = self.net(xb) #probabilities = self.net(img_tensor)
#prob, preds = torch.max(yb, dim=1) #probabilities = F.softmax(probabilities, dim = 1)
#output = torch.nn.functional.softmax(yb[0], dim=0)
#confidence, index = torch.max(yb, dim=1)
#return (self.classes[index[0].item()], confidence[0].item())
def infer(self, path):
img = Image.open(path)
preprocess = transforms.Compose([
transforms.Resize((300, 300)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
image_tensor = preprocess(img)
# create a mini-batch as expected by the model
input_batch = to_device(image_tensor.unsqueeze(0), self.device)
with torch.no_grad():
output = self.net(input_batch)
#The output has unnormalized scores. To get probabilities, you can run a softmax on it.
confidence, index = torch.max(output, dim=1)
return (index[0].item(), confidence[0].item())
class Brain:
def __init__(self, num_states, num_actions, Double, Dueling, PER):
self.num_actions = num_actions # 행동 가짓수(2)를 구함
self.Double = Double
self.Dueling = Dueling
self.PER = PER
# transition을 기억하기 위한 메모리 객체 생성
self.memory = ReplayMemory(CAPACITY)
# 신경망 구성
n_in, n_mid, n_out = num_states, 32, num_actions
self.main_q_network = Net(n_in, n_mid, n_out, Dueling) # Net 클래스를 사용
self.target_q_network = Net(n_in, n_mid, n_out, Dueling) # Net 클래스를 사용
print(self.main_q_network) # 신경망의 구조를 출력
# 최적화 기법을 선택
self.optimizer = optim.Adam(self.main_q_network.parameters(), lr=0.0001)
# PER - TD 오차를 기억하기 위한 메모리 객체 생성
if self.PER == True:
self.td_error_memory = TDerrorMemory(CAPACITY)
def replay(self, episode = 0):
''' Experience Replay로 신경망의 결합 가중치 학습 '''
# 1. 저장된 transition 수 확인
if len(self.memory) < BATCH_SIZE:
return
# 2. 미니배치 생성
if self.PER == True:
self.batch, self.state_batch, self.action_batch, self.reward_batch, self.non_final_next_states = self.make_minibatch(episode)
else:
self.batch, self.state_batch, self.action_batch, self.reward_batch, self.non_final_next_states = self.make_minibatch()
# 3. 정답신호로 사용할 Q(s_t, a_t)를 계산
self.expected_state_action_values = self.get_expected_state_action_values()
# 4. 결합 가중치 수정
self.update_main_q_network()
def decide_action(self, state, episode):
'''현재 상태로부터 행동을 결정함'''
# e-greedy 알고리즘에서 서서히 최적행동의 비중을 늘린다
epsilon = 0.5 * (1 / (episode +1))
if epsilon <= np.random.uniform(0, 1):
self.main_q_network.eval() # 신경망을 추론 모드로 전환
with torch.no_grad():
action = self.main_q_network(state).max(1)[1].view(1, 1)
# 신경망 출력의 최댓값에 대한 인덱스 = max(1)[1]
# .view(1,1)은 [torch.LongTensor of size 1]을 size 1*1로 변환하는 역할을 함
else:
# 행동을 무작위로 반환 (0 혹은 1)
action = torch.LongTensor([[random.randrange(self.num_actions)]]) #행동을 무작위로 반환(0 혹은 1)
# action은 [torch.LongTensor of size 1*1] 형태가 된다.
return action
def make_minibatch(self, episode = 0):
'''2. 미니배치 생성'''
if self.PER == True:
# 2.1 PER - 메모리 객체에서 미니배치를 추출
# def make_minibatch(self, episode):
if episode < 30:
transitions = self.memory.sample(BATCH_SIZE)
else:
# TD 오차를 이용해 미니배치를 추출하도록 수정
indexes = self.td_error_memory.get_prioritized_indexes(BATCH_SIZE)
transitions = [self.memory.memory[n] for n in indexes]
else:
# 2.1 메모리 객체에서 미니배치를 추출
transitions = self.memory.sample(BATCH_SIZE)
# 2.2 각 변수를 미니배치에 맞는 형태로 변형
# transitions는 각 단계별로 (state, action, state_next, reward) 형태로 BATCH_SIZE 개수만큼 저장됨
# 다시 말해, (state, action, state_next, reward) * BATCH_SIZE 형태가 된다.
# 이를 미니배치로 만들기 위해
# (state*BATCH_SIZE, action*BATCH_SIZE), state_next*BATCH_SIZE, reward*BATCH_SIZE)
# 형태로 변환한다.
batch = Transition(*zip(*transitions))
# 2.3 각 변수의 요소를 미니배치에 맞게 변형하고, 신경망으로 다룰 수 있게 Variable로 만든다
# state를 예로 들면, [torch.FloatTensor of size 1*4] 형태의 요소가 BATCH_SIZE 개수만큼 있는 형태다
# 이를 torch.FloatTensor of size BATCH_SIZE*4 형태로 변형한다
# 상태, 행동, 보상, non_final 상태로 된 미니배치를 나타내는 Variable을 생성
# cat은 Concatenates(연접)를 의미한다.
state_batch = torch.cat(batch.state)
action_batch = torch.cat(batch.action)
reward_batch = torch.cat(batch.reward)
non_final_next_states = torch.cat([s for s in batch.next_state if s is not None])
return batch, state_batch, action_batch, reward_batch, non_final_next_states
def get_expected_state_action_values(self):
''' 정답 신호로 사용할 Q(s_t,a_t)를 계산'''
# 3.1 신경망을 추론 모드로 전환
self.main_q_network.eval()
self.target_q_network.eval()
# 3.2 신경망으로 Q(s_t, a_t)를 계산
# self.model(state_batch)은 왼쪽, 오른쪽에 대한 Q값을 출력하며
# [torch.FloatTensor of size BATCH_SIZEx2] 형태다
# 여기서부터는 실행한 행동 a_t에 대한 Q값을 계산하므로 action_batch에서 취한 행동
# a_t가 왼쪽이냐 오른쪽이냐에 대한 인덱스를 구하고, 이에 대한 Q값을 gather메서드로 모아온다.
self.state_action_values = self.main_q_network(self.state_batch).gather(1, self.action_batch)
# 3.3 max{Q(s_t+1, a)}값을 계산한다. 이때 다음 상태가 존재하는지에 주의해야 한다
# cartpole이 done 상태가 아니고, next_state가 존재하는지 확인하는 인덱스 마스크를 만듬
non_final_mask = torch.ByteTensor(tuple(map(lambda s: s is not None, self.batch.next_state)))
# 먼저 전체를 0으로 초기화
next_state_values = torch.zeros(BATCH_SIZE)
# Double DQN
if self.Double == True:
a_m = torch.zeros(BATCH_SIZE).type(torch.LongTensor)
# 다음 상태에서 Q값이 최대가 되는 행동 a_m을 Main Q-Network로 계산
# 마지막에 붙은 [1]로 행동에 해당하는 인덱스를 구함
a_m[non_final_mask] = self.main_q_network(self.non_final_next_states).detach().max(1)[1]
# 다음 상태가 있는 것만을 걸러내고, size 32를 32*1로 변환
a_m_non_final_next_states = a_m[non_final_mask].view(-1, 1)
# 다음 상태가 있는 인덱스에 대해 행동 a_m의 Q값을 target Q-Network로 계산
# detach() 메서드로 값을 꺼내옴
# squeeze()메서드로 size[minibatch*1]을 [minibatch]로 변환
next_state_values[non_final_mask] = self.target_q_network(
self.non_final_next_states).gather(1, a_m_non_final_next_states).detach().squeeze()
else:
# 다음 상태가 있는 인덱스에 대한 최대 Q값을 구한다
# 출력에 접근해서 열방향 최댓값(max(1))이 되는 [값, 인덱스]를 구한다
# 그리고 이 Q값(인덱스 = 0)을 출력한 다음
# detach 메서드로 이 값을 꺼내온다
next_state_values[non_final_mask] = self.target_q_network(self.non_final_next_states).max(1)[0].detach()
# 3.4 정답신호로 사용할 Q(s_t, a_t) 값을 Q러닝 식으로 계산
expected_state_action_values = self.reward_batch + GAMMA * next_state_values
return expected_state_action_values
def update_main_q_network(self):
''' 4. 결합 가중치 수정 '''
# 4.1 신경망을 학습 모드로 전환
self.main_q_network.train()
# 4.2 손실함수를 계산(smooth_l1_loss는 Huber 함수)
# expected_state_action_values은 size가 [minibatch]이므로 unsqueeze해서 [minibatch*1]로 만듦
loss = F.smooth_l1_loss(self.state_action_values, self.expected_state_action_values.unsqueeze(1))
# 4.3 결합 가중치를 수정
self.optimizer.zero_grad() # 경사를 초기화
loss.backward() # 역전파 계산
self.optimizer.step() # 결합 가중치 수정
def update_target_q_network(self): # DDQN에서 추가됨
''' Target Q-Network을 Main Q-Network와 맞춤 '''
self.target_q_network.load_state_dict(self.main_q_network.state_dict())
def update_td_error_memory(self): # Prioritized Experience Replay 에서 추가됨
''' TD 오차 메모리에 저장된 TD 오차를 업데이트 '''
# 신경망을 추론 모드로 전환
self.main_q_network.eval()
self.target_q_network.eval()
# 전체 transition으로 미니배치를 생성
transitions = self.memory.memory
batch = Transition(*zip(*transitions))
state_batch = torch.cat(batch.state)
action_batch = torch.cat(batch.action)
reward_batch = torch.cat(batch.reward)
non_final_next_states = torch.cat([s for s in batch.next_state if s is not None])
# 신경망의 출력 Q(s_t, a_t)를 계산
state_action_values = self.main_q_network(state_batch).gather(1, action_batch)
# cartpole이 done 상태가 아니고, next_state가 존재하는지 확인하는 인덱스 마스크를 만듦
non_final_mask = torch.ByteTensor(tuple(map(lambda s: s is not None, batch.next_state)))
# 먼저 전체를 0으로 초기화, 크기는 기억한 transition 개수만큼
next_state_values = torch.zeros(len(self.memory))
a_m = torch.zeros(len(self.memory)).type(torch.LongTensor)
# 다음 상태에서 Q값이 최대가 되는 행동 a_m을 Main Q-Network로 계산
# 마지막에 붙은 [1]로 행동에 해당하는 인덱스를 구함
a_m[non_final_mask] = self.main_q_network(non_final_next_states).detach().max(1)[1]
# 다음 상태가 있는 것만을 걸러내고, size 32를 32*1 로 변환
a_m_non_final_next_states = a_m[non_final_mask].view(-1, 1)
# 다음 상태가 있는 인덱스에 대해 행동 a_m의 Q값을 target Q-Network로 계산
# detach() 메서드로 값을 꺼내옴
# squeeze() 메서드로 size[minibatch*1]을 [minibatch]로 변환
next_state_values[non_final_mask] = self.target_q_network(
non_final_next_states).gather(1, a_m_non_final_next_states).detach().squeeze()
# TD 오차를 계산
td_errors = (reward_batch + GAMMA * next_state_values) - state_action_values.squeeze()
# state_action_values는 size[minibatch*1]이므로 squeeze 메서드로 size[minibatch]로 변환
# TD 오차 메모리를 업데이트. Tensor를 detach() 메서드로 꺼내와 NumPy 변수로 변환하고
# 다시 파이썬 리스트로 반환
self.td_error_memory.memory = td_errors.detach().numpy().tolist()
def train(n_epochs=n_epochs,
train_loader=train_loader,
valid_loader=valid_loader,
save_location_path=save_location_path):
train_on_gpu = torch.cuda.is_available()
def init_weights(m):
if isinstance(m, nn.Linear):
I.xavier_uniform_(m.weight)
model = Net()
model.apply(init_weights)
if train_on_gpu:
model.cuda()
criterion = nn.MSELoss()
optimizer = optim.Adam(params=model.parameters(), lr=0.001)
valid_loss_min = np.Inf
model.train()
for epoch in range(1, n_epochs + 1):
# Keep track of training and validation loss
train_loss = 0.0
valid_loss = 0.0
for data in train_loader:
# Grab the image and its corresponding label
images = data['image']
key_pts = data['keypoints']
if train_on_gpu:
images, key_pts = images.cuda(), key_pts.cuda()
# Flatten keypoints & convert data to FloatTensor for regression loss
key_pts = key_pts.view(key_pts.size(0), -1)
if train_on_gpu:
key_pts = key_pts.type(torch.cuda.FloatTensor)
images = images.type(torch.cuda.FloatTensor)
else:
key_pts = key_pts.type(torch.FloatTensor)
images = images.type(torch.FloatTensor)
optimizer.zero_grad() # Clear the gradient
output = model(images) # Forward
loss = criterion(output, key_pts) # Compute the loss
loss.backward() # Compute the gradient
optimizer.step() # Perform updates using calculated gradients
train_loss += loss.item() * images.size(0)
# Validation
model.eval()
for data in valid_loader:
images = data['image']
key_pts = data['keypoints']
if train_on_gpu:
images, key_pts = images.cuda(), key_pts.cuda()
key_pts = key_pts.view(key_pts.size(0), -1)
if train_on_gpu:
key_pts = key_pts.type(torch.cuda.FloatTensor)
images = images.type(torch.cuda.FloatTensor)
else:
key_pts = key_pts.type(torch.FloatTensor)
images = images.type(torch.FloatTensor)
output = model(images)
loss = criterion(output, key_pts)
valid_loss += loss.item() * images.size(0)
# calculate average losses
train_loss = train_loss / len(train_loader)
valid_loss = valid_loss / len(valid_loader)
print(
f"epoch: {epoch} \t trainLoss: {train_loss} \t valLoss: {valid_loss}"
)
eviz.send_data(current_epoch=epoch,
current_train_loss=train_loss,
current_val_loss=valid_loss)
class Agent:
"""Interacts with and learns from the environment."""
def __init__(self):
self.actions = 4
self.state_space = 37
self.memory = deque(maxlen = 100000)
self.randomness = 1
self.least_randomness = 0.01
self.randomness_decay = 0.995
self.gamma = 0.95
self.network = Net()
self.qtarget_net = Net()
self.optimizer = optim.Adam(self.network.parameters(), lr=3e-4)
self.loss_func = nn.MSELoss()
self.tau = 1e-3
def remember(self, state, next_state, action, reward, done):
"""stores state, next_state, action, reward and done"""
self.memory.append([state, next_state, action, reward, done])
def action(self, state):
"""returns an action that has to be taken given the state"""
if random.random() < self.randomness:
return random.randint(0, self.actions - 1)
state = torch.from_numpy(np.array(state).reshape(1, self.state_space)).float()
self.network.eval()
with torch.no_grad():
action_values = self.network(state)
self.network.train()
#
return np.argmax(action_values.detach().numpy())
def save(self, name):
"""save the model"""
torch.save(self.network.state_dict(), name)
def load_checkpoint(self, name):
"""load the model from memory"""
self.network.load_state_dict(torch.load(name))
def train(self, batch_size = 128):
"""trains the network based on previous experiences"""
try:
memory_buffer = random.choices(self.memory, k = batch_size)
except:
memory_buffer = self.memory
predictions = []
actuals = []
states = []
next_states = []
actions = []
rewards = []
dones = []
for state, next_state, action, reward, done in memory_buffer:
states.append(state)
next_states.append(next_state)
actions.append(action)
rewards.append(reward)
dones.append(done)
states, next_states, actions, rewards, dones = [np.array(x).astype(np.float32) for x in [states, next_states, actions, rewards, dones]]
#print(actions.shape)
dones = dones.astype(np.uint8)
states, next_states, actions, rewards, dones = [torch.from_numpy(x).float() for x in [states, next_states, actions, rewards, dones]]
actions = actions.view(-1, 1)
rewards = rewards.view(-1, 1)
#print(actions.shape, states.shape)
dones = dones.view(-1, 1)
#print([x.shape for x in [states, actions, rewards, next_states, dones]])
Q_targets_next = self.qtarget_net(next_states).detach().max(1)[0].unsqueeze(1)
Q_targets = rewards + (self.gamma * Q_targets_next * (1 - dones))
Q_expected = self.network(states).gather(1, actions.long())
#print(Q_expected.shape, Q_targets.shape)
loss = self.loss_func(Q_expected, Q_targets)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
self.randomness = max(self.least_randomness, self.randomness*self.randomness_decay)
for target_param, local_param in zip(self.qtarget_net.parameters(), self.network.parameters()):
target_param.data.copy_(self.tau*local_param.data + (1.0-self.tau)*target_param.data)
class Trainer:
def __init__(self, name="openspieltest", backup="on-policy"):
# Experiment Parameters
self.name_game = "connect_four" #"breakthrough(rows=6,columns=6)" # Name of game (should be from open_spiel library)
self.name_run = name # Name of run
self.model_path = "models/" # Path to save the models
self.save = True # Save neural network
self.save_n_gens = 10 # How many iterations until network save
self.test_n_gens = 10 # How many iterations until testing
self.n_tests = 200 # How many tests to perform for testing
self.use_gpu = True # Use GPU (if available)
self.n_pools = 1 # Amount of worker pools to create (also amount of GPU's to utilize)
self.n_processes = 1 # Amount of game processes to start for every pool.
# Algorithm Parameters
self.n_games_per_generation = 500 # How many games to generate per iteration
self.n_batches_per_generation = 500 # How batches of neural network training per iteration
self.n_games_buffer_max = 20000 # How many games to store in FIFO buffer, at most. Buffer is grown.
self.batch_size = 256 # Batch size for neural network training
self.lr = 0.001 # Learning rate for neural network
self.n_games_buffer = 4 * self.n_games_per_generation
self.temperature = 1.0
self.dirichlet_ratio = 0.25
self.uct_train = 2.5
self.uct_test = 2.5
self.n_playouts_train = 100
self.backup = backup
self.tree_strap = False
self.it = 0
# Initialization of the trainer
self.generation = 0
self.game = pyspiel.load_game(self.name_game)
self.buffer = []
self.num_distinct_actions = self.game.num_distinct_actions()
self.state_shape = self.game.information_state_normalized_vector_shape(
)
self.game = pyspiel.load_game(self.name_game)
self.games_played = 0
self.start_time = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
# Initialize logger
formatter = logging.Formatter('%(asctime)s %(message)s')
logger.setLevel('DEBUG')
fh = logging.FileHandler("logs/" + str(self.start_time) +
str(self.name_run) + ".log")
fh.setFormatter(formatter)
fh.setLevel('INFO')
ch = logging.StreamHandler()
ch.setLevel('INFO')
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fh)
logger.info('Logger started')
logger.info(str(torch.cuda.is_available()))
logger.info(str(backup))
# Setup CUDA if possible
if self.use_gpu:
if not torch.cuda.is_available():
logger.info("Tried to use GPU, but none is available")
self.use_gpu = False
self.device = torch.device("cuda:0" if self.use_gpu else "cpu")
# Initialize neural net
self.current_net = Net(self.state_shape,
self.num_distinct_actions,
device=self.device)
self.current_net.to(self.device)
self.optimizer = torch.optim.Adam(self.current_net.parameters(),
lr=self.lr,
weight_decay=0.0001)
self.criterion_policy = nn.BCELoss()
self.criterion_value = nn.MSELoss()
self.current_net.eval()
# Log the settings.
logger.info(self.__dict__)
logger.info("Using:" + str(self.device))
def net_step(self, flattened_buffer):
""" Samples a random batch and updates the NN parameters with this batch
Args:
flattened_buffer: a flat buffer with examples from which to sample from
Returns:
loss_p: loss of the policy criterion
loss_v: loss of the value criterion
"""
self.current_net.zero_grad()
# Select samples and format them to use as batch
sample_ids = np.random.randint(len(flattened_buffer),
size=self.batch_size)
x = [flattened_buffer[i][1] for i in sample_ids]
p_r = [flattened_buffer[i][2] for i in sample_ids]
v_r = [flattened_buffer[i][3] for i in sample_ids]
x = torch.from_numpy(np.array(x)).float().to(self.device)
# Pass through network
p_t, v_t = self.current_net(x)
p_r = [
item if item else p_t[i, :].to("cpu").tolist()
for i, item in enumerate(p_r)
]
p_r = torch.tensor(np.array(p_r)).float().to(self.device)
v_r = torch.tensor(np.array(v_r)).float().to(self.device)
# Backward pass
loss_v = self.criterion_value(v_t, v_r.unsqueeze(1))
loss_p = -torch.sum(p_r * torch.log(p_t)) / p_r.size()[0]
loss = loss_v + loss_p
loss.backward()
self.optimizer.step()
self.it += 1
return loss_p, loss_v
def train_network(self):
"""Trains the neural network for batches_per_generation batches.
"""
logger.info("Training Network")
self.current_net.train()
flattened_buffer = [sample for game in self.buffer for sample in game]
flattened_buffer = self.remove_duplicates(flattened_buffer)
loss_tot_v = 0
loss_tot_p = 0
for i in range(self.n_batches_per_generation):
loss_p, loss_v = self.net_step(flattened_buffer)
loss_tot_p += loss_p
v = loss_v
loss_tot_v += v
if i % 100 == 99:
logger.info("Batch: " + str(i) + "Loss policy: " +
str(loss_tot_p / 100.) + "Loss value: " +
str(loss_tot_v / 100.))
loss_tot_v = 0
loss_tot_p = 0
self.current_net.eval()
@staticmethod
def remove_duplicates(flattened_buffer):
"""Removes duplicates from a flattened buffer by averaging values and policy.
Args:
flattened_buffer: flat buffer with examples from where the duplicates need to be removed.
Returns: flat buffer with duplicates removed.
"""
logger.info("Removing duplciates")
logger.info("Initial amount of samples: " + str(len(flattened_buffer)))
start = time.time()
# Remove duplicates
flattened_buffer_dict = dict()
flattened_buffer_counts = dict()
flattened_buffer_pol = dict()
for item in flattened_buffer:
if item[0] in flattened_buffer_dict:
# Average policy
if item[2] and flattened_buffer_dict[item[0]][2]:
flattened_buffer_dict[item[0]][2] = [
sum(x) for x in zip(flattened_buffer_dict[item[0]][2],
item[2])
]
flattened_buffer_pol[item[0]] += 1
elif item[2]:
flattened_buffer_dict[item[0]][2] = item[2]
# Average value
flattened_buffer_dict[item[0]][3] += item[3]
flattened_buffer_counts[item[0]] += 1
else:
flattened_buffer_dict[item[0]] = item
flattened_buffer_counts[item[0]] = 1
flattened_buffer_pol[item[0]] = 1
for key, value in flattened_buffer_dict.items():
if flattened_buffer_dict[key][2]:
flattened_buffer_dict[key][2] = [
x / flattened_buffer_pol[key]
for x in flattened_buffer_dict[key][2]
]
flattened_buffer_dict[key][3] = flattened_buffer_dict[key][
3] / flattened_buffer_counts[key]
flattened_buffer = list(flattened_buffer_dict.values())
logger.info("New amount of samples: " + str(len(flattened_buffer)))
logger.info("Duplication removal took:" + str(time.time() - start) +
"seconds")
return flattened_buffer
def generate_examples(self, n_games):
"""Generates new games in a multithreaded way.
Arg:
n_games: amount of games to generate
"""
logger.info("Generating Data")
start = time.time()
# Generate the examples
generator = ExampleGenerator(self.current_net,
self.name_game,
self.device,
n_playouts=self.n_playouts_train,
temperature=self.temperature,
dirichlet_ratio=self.dirichlet_ratio,
c_puct=self.uct_train,
backup=self.backup,
tree_strap=self.tree_strap,
n_pools=self.n_pools,
n_processes=self.n_processes)
games = generator.generate_examples(n_games)
self.games_played += self.n_games_per_generation
# Add examples to buffer
for examples in games:
self.buffer.append(examples)
logger.info("Finished Generating Data (threaded). Took: " +
str(time.time() - start) + " seconds")
logger.info("Total amount of games played:" +
str(self.generation * self.n_games_per_generation))
self.update_buffer_size()
# Remove oldest entries from buffer if too long
if len(self.buffer) > self.n_games_buffer:
logger.info("Buffer full. Deleting oldest samples.")
while len(self.buffer) > self.n_games_buffer:
del self.buffer[0]
def test_agent(self):
"""Tests the current agent
Tests against random opponents and pure MCTS agents
"""
start = time.time()
logger.info("Testing...")
generator = ExampleGenerator(self.current_net,
self.name_game,
self.device,
is_test=True,
temperature=self.temperature,
dirichlet_ratio=self.dirichlet_ratio,
c_puct=self.uct_test,
n_pools=self.n_pools,
n_processes=self.n_processes)
score_tot = 0.
for i in range(self.n_tests):
score1, score2 = test_net_vs_random(self.current_net.predict,
self.name_game)
score_tot += score1
score_tot += score2
avg = score_tot / (2 * self.n_tests)
logger.info("Average score vs random (net only):" + str(avg))
avg = generator.generate_tests(self.n_tests, test_net_vs_mcts, 100)
logger.info("Average score vs mcts100 (net only):" + str(avg))
avg = generator.generate_tests(self.n_tests, test_zero_vs_mcts, 200)
logger.info("Average score vs mcts200:" + str(avg))
avg = generator.generate_tests(self.n_tests, test_net_vs_mcts, 200)
logger.info("Average score vs mcts200 (net only):" + str(avg))
logger.info("Testing took: " + str(time.time() - start) + "seconds")
return
def run(self):
"""Main alphaZero training loop
"""
# Start with testing the agent
self.test_agent()
while self.generation < 201:
self.generation += 1
logger.info("Generation:" + str(self.generation))
self.generate_examples(self.n_games_per_generation
) # Generate new games through self-play
self.train_network() # Train network on games in the buffer
# Perform testing periodically
if self.generation % self.test_n_gens == 0: # Test the alphaZero bot against MCTS bots
self.test_agent()
# Periodically save network
if self.save and self.generation % self.save_n_gens == 0:
logger.info("Saving network")
torch.save(
self.current_net.state_dict(), self.model_path +
self.name_run + str(self.generation) + ".pth")
logger.info("Network saved")
def update_buffer_size(self):
if self.generation % 2 == 0 and self.n_games_buffer < self.n_games_buffer_max:
self.n_games_buffer += self.n_games_per_generation
logger.info("Buffer size:" + str(self.n_games_buffer))
thld = np.arange(0, 1, 0.05)
accu_tp = []
accu_fp = []
accu_iou = []
for epoch in range(1):
for i, data in enumerate(loader, 0):
# get the inputs
inputs, labels = data
inputs, labels = inputs.float() / 256, labels.float()
#
# # wrap them in Variable
#
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
#
threshold = 0.4
net.eval()
predicts = net.forward(inputs)
# loss, accu = net.loss_function_vec(outputs, labels, threshold, cal_accuracy=True)
#
#
# # print (datetime.datetime.now())
# # print ('Epoch %g'%(epoch))
# print(loss.data.cpu().numpy())
# print(accu)
# accu_tp.append(accu[0].data.cpu().numpy()[0])
# accu_fp.append(accu[1].data.cpu().numpy()[0])
# accu_iou.append(accu[2].data.cpu().numpy()[0])
#
# plt.plot(thld, accu_tp, 'r')
# plt.plot(thld, accu_fp, 'b')
# plt.plot(thld, accu_iou, 'g')
'learning rate', scheduler.get_lr()[0], epoch)
# 记录Accuracy
writer.add_scalars('Accuracy_group', {
'train_acc': correct / total}, epoch)
# 每个epoch，记录梯度，权值
# for name, layer in cnn.named_parameters():
# writer.add_histogram(
# name + '_grad', layer.grad.cpu().data.numpy(), epoch)
# writer.add_histogram(name + '_data', layer.cpu().data.numpy(), epoch)
# ------------------------------------ 观察模型在验证集上的表现 ------------------------------------
if epoch % 1 == 0:
loss_sigma = 0.0
cls_num = 10
conf_mat = np.zeros([cls_num, cls_num]) # 混淆矩阵
cnn.eval()
for batch_idx, data in enumerate(test_loader):
images, labels = data
images, labels = images.cuda(), labels.cuda()
images = images.double()
labels = labels.double()
cnn.cuda()
cnn = cnn.train()
outputs = cnn(images) # forward
outputs.detach_() # 不求梯度
loss = criterion(outputs, torch.max(labels, 1)[1]) # 计算loss
# x = Variable(loss,requires_grad=True)
# loss = loss.requires_grad()
class testNetwork():
def __init__(self):
self.class_num = args.class_num
self.batch_num = args.batch_num
self.test_input_path = os.path.join(args.test_path, 'CORD', 'test',
'BERTgrid')
self.test_label_path = os.path.join(args.test_path, 'CORD', 'test',
'LABELgrid')
weight_path = os.path.join(args.test_path, 'params', args.weight)
self.model = Net()
self.model.cuda()
self.model.load_state_dict(torch.load(weight_path))
if args.lossname == 'CrossEntropy':
self.criterion = nn.CrossEntropyLoss()
def list_files(self, in_path):
img_files = []
for (dirpath, dirnames, filenames) in os.walk(in_path):
for file in filenames:
filename, ext = os.path.splitext(file)
ext = str.lower(ext)
if ext == '.png':
img_files.append(file)
# img_files.append(os.path.join(dirpath, file))
img_files.sort()
return img_files
def load_data(self, img_names, label_names):
assert len(img_names) == len(label_names)
for idx in range(len(img_names)):
image = cv2.imread(img_names[idx])
label = cv2.imread(label_names[idx])
images = np.zeros((1, self.b_size, self.b_size, 3))
labels = np.zeros((1, self.b_size, self.b_size, 3))
image = np.expand_dims(image, axis=0)
label = np.expand_dims(label, axis=0)
_, hei, wid, _ = image.shape
for h in range(0, hei, self.b_size):
for w in range(0, wid, self.b_size):
if h + self.b_size < hei:
start_h, end_h = h, h + self.b_size
else:
start_h, end_h = hei - self.b_size - 1, hei - 1
if w + self.b_size < wid:
start_w, end_w = w, w + self.b_size
else:
start_w, end_w = wid - self.b_size - 1, wid - 1
temp_image = image[:, start_h:end_h, start_w:end_w, :]
temp_label = label[:, start_h:end_h, start_w:end_w, :]
images = np.concatenate((images, temp_image), axis=0)
labels = np.concatenate((labels, temp_label), axis=0)
return images, labels
def val_epoch(self, input_lists):
self.model.eval()
losses = 0
for batch in range(int(len(input_lists) / self.batch_num)):
self.optimizer.zero_grad()
input_list, label_list = [], []
for num in range(self.batch_num):
idx = batch * self.batch_num + num
filename = input_lists[idx]
input_list.append(self.input_path + '/' + filename)
label_list.append(self.label_path + '/' + filename)
train_input, train_label = self.load_data(input_list, label_list)
input_tensor = torch.tensor(train_input, dtype=torch.float).cuda()
input_tensor = input_tensor.permute(0, 3, 1, 2)
label_tensor = torch.tensor(train_label, dtype=torch.float).cuda()
label_tensor = label_tensor.permute(0, 3, 1, 2)
output = self.model(input_tensor)
loss = self.criterion(output, label_tensor)
losses += loss.item()
return losses / self.batch_num
# def testMany(self):
# test_lists = self.list_files(self.test_input_path)
# val_loss, val_acc, val_mic, val_mac = self.val_epoch(test_lists)
# print('\tVal Loss: %.3f | Val Acc: %.2f%% | mic: %.2f%% | mac: %.2f%%' % (val_loss, val_acc*100, val_mic*100, val_mac*100))
def testOne(self, img_path):
self.model.eval()
input = cv2.imread(img_path)
input_tensor = torch.tensor(input, dtype=torch.float).cuda()
input_tensor = input_tensor.unsqueeze(0)
input_tensor = input_tensor.permute(0, 3, 1, 2)
output = self.model(input_tensor)
output = output.permute(0, 2, 3, 1)
output = output.squeeze(0)
output = output.cpu().detach().numpy()
return output
def __main__():
ap = argparse.ArgumentParser(
description='A simple face detector for batch processing')
ap.add_argument('--biggest',
action="store_true",
help='Extract only the biggest face')
ap.add_argument('--best',
action="store_true",
help='Extract only the best matching face')
ap.add_argument('-c',
'--center',
action="store_true",
help='Print only the center coordinates')
ap.add_argument('--data-dir',
metavar='DIRECTORY',
default=DATA_DIR,
help='OpenCV data files directory')
ap.add_argument('-q',
'--query',
action="store_true",
help='Query only (exit 0: face detected, 2: no detection)')
ap.add_argument(
'-s',
'--search',
metavar='FILE',
help='Search for faces similar to the one supplied in FILE')
ap.add_argument('--search-threshold',
metavar='PERCENT',
type=int,
default=30,
help='Face similarity threshold (default: 30%%)')
ap.add_argument('-o', '--output', help='Image output file')
ap.add_argument('-d',
'--debug',
action="store_true",
help='Add debugging metrics in the image output file')
ap.add_argument('file', help='Input image file')
args = ap.parse_args()
load_cascades(args.data_dir)
model = Net()
model.load_state_dict(torch.load('model.pt'))
# detect faces in input image
im, features = face_detect_file(args.file, args.query or args.biggest)
# match against the requested face
sim_scores = None
if args.search:
s_im, s_features = face_detect_file(args.search, True)
if len(s_features) == 0:
fatal("cannot detect face in template")
sim_scores = []
sim_features = []
sim_threshold = args.search_threshold / 100
sim_template = norm_rect(s_im, s_features[0])
for i, score in enumerate(
pairwise_similarity(im, features, sim_template)):
if score >= sim_threshold:
sim_scores.append(score)
sim_features.append(features[i])
features = sim_features
# exit early if possible
if args.query:
return 0 if len(features) else 2
# compute scores
scores = []
best = None
if len(features) and (args.debug or args.best or args.biggest
or sim_scores):
scores, best = rank(im, features)
if sim_scores:
for i in range(len(features)):
scores[i]['MSSIM'] = sim_scores[i]
# debug features
if True:
im = cv2.imread(args.file)
font = cv2.FONT_HERSHEY_SIMPLEX
fontHeight = cv2.getTextSize("", font, 0.5, 1)[0][1] + 5
for i in range(len(features)):
if best is not None and i != best and not args.debug:
next
rect = features[i]
fg = (0, 255, 255) if i == best else (255, 255, 255)
xy1 = (rect[0], rect[1])
xy2 = (rect[0] + rect[2], rect[1] + rect[3])
cv2.rectangle(im, xy1, xy2, (0, 0, 0), 4)
cv2.rectangle(im, xy1, xy2, fg, 2)
fontScale = 0.80
fontColor = (255, 255, 255)
lineType = 2
image = cv2.imread(args.file)
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
image = image[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]]
cv2.imwrite('face{}.png'.format(i + 1), image)
image = cv2.resize(image, (WIDTH, HEIGHT))
image = torch.tensor(image, dtype=torch.float)
model.eval()
output = model(image)
output = torch.nn.functional.softmax(output, dim=1)
_, preds = torch.max(output, 1)
pred = PEOPLE[preds[0].item()]
cv2.putText(im, pred, (rect[0], rect[1] - 5), font, fontScale,
fontColor, lineType)
cv2.imwrite("output.png", im)
# output
if (args.best or args.biggest) and best is not None:
features = [features[best]]
return 0
def run(args):
env = gym.make(args.env_name)
observation = env.reset()
steps_per_episode = args.steps
model_file_output_path = args.from_file
should_recycle_population = args.recycle_population
# N is episode steps length; D_in is input observation dimension;
# H is hidden layer dimension; D_out is output action space dimension.
N, D_in, H, D_out = args.batch_size, observation.shape[0], 40, 1
agent = Agent(env, steps_per_episode, args.maximize, args.reward_reducer)
model = Net(N, D_in, H, D_out, agent)
# set log level
agent.log_level = args.log_level
if args.load_model:
model.load_state_dict(torch.load(model_file_output_path))
model.eval()
# connect network to agent
agent.attach_model(model)
if args.load_model:
agent.run_forever(steps_per_episode)
exit()
# fill
model.train()
scaling_factor = args.scaling_factor
crossover_rate = args.crossover_rate
population_size = args.population_size
episodes_num = args.episodes # number of episodes
# generate flattened weights
model.flatten()
problem_size = model.flattened.shape[0]
print("problem_size: ", problem_size)
# Initial population, Fitness values
x = torch.randn(population_size, problem_size, dtype=torch.float64)
y = torch.randn(population_size, D_out, dtype=torch.float64)
# Convert to c pointers
x_c = x.detach().numpy().ctypes.data_as(c.POINTER(
c.c_double)) # c pointer init population
y_c = y.detach().numpy().ctypes.data_as(c.POINTER(
c.c_double)) # c pointer init fitness values
agent.out_population = x.detach().numpy()
agent.out_fitnesses = y.detach().numpy()
# TODO: make these adjustable
optimizer = getattr(devo, args.optimizer_name)
generations = episodes_num // population_size
# Runs 1 generation of DE at a time, using previous run's out population
# as an input for the next one
if should_recycle_population:
for g in range(generations):
# # Using Adaptive-DEs
optimizer.run(
population_size,
population_size, # population size
scaling_factor, # scaling factor
crossover_rate, # crossover rate
agent.objective_func,
problem_size, # problem size
-100, # unused value
100, # unused value
x_c,
y_c,
agent.results_callback # no results callback needed
)
x_c = agent.out_population.ctypes.data_as(c.POINTER(c.c_double))
y_c = agent.out_fitnesses.ctypes.data_as(c.POINTER(c.c_double))
else:
# # Using Adaptive-DEs
optimizer.run(
episodes_num,
population_size, # population size
scaling_factor, # scaling factor
crossover_rate, # crossover rate
agent.objective_func,
problem_size, # problem size
-100, # unused value
100, # unused value
x_c,
y_c,
agent.results_callback # no results callback needed
)
# Get mins - inverted in output
print("min_fitness: ", agent.min_reward)
model.update_weights_from_vec(agent.min_weights)
result = -agent.run_episode(agent.steps_per_episode, True)
if args.should_test:
print("test_run(expected: {}, actual: {})".format(
agent.min_reward, result))
env.close()
if args.save_model:
print("model_file: ", model_file_output_path)
# save model
torch.save(model.state_dict(), model_file_output_path)
