def train_test():
for k in model_select:
table = BeautifulTable()
avgtable = BeautifulTable()
fieldnames1 = [model_lst[k],'Avg','Std_dev'] #column names report GLOBAL CSV
folder = os.path.join(cwd,'Report_'+str(model_lst[k]))
if not os.path.exists(folder):
os.mkdir(folder)
logfilepath = os.path.join(folder,'log.txt')
logfile = open(logfilepath,"w")
with open(os.path.join(folder,'Report_folds.csv'),'w') as f_fold, open(os.path.join(folder,'Report_global.csv'),'w') as f_global:
writer = csv.DictWriter(f_fold, fieldnames = fieldnames)
writer1 = csv.DictWriter(f_global, fieldnames = fieldnames1)
writer.writeheader()
writer1.writeheader()
t0 = 0
t1 = 0
for i in range(1,nfold+1):
t0 = time.time()
setSeeds(0)
class Traindataset(Dataset):
def __init__(self):
self.data=trainfolds[i-1]
self.x_data=torch.from_numpy(np.asarray(self.data.iloc[:, 0:-1]))
self.len=self.data.shape[0]
self.y_data = torch.from_numpy(np.asarray(self.data.iloc[:, [-1]]))
if (use_cuda):
self.x_data = self.x_data.cuda()
self.y_data = self.y_data.cuda()
def __getitem__(self, index):
return self.x_data[index], self.y_data[index]
def __len__(self):
return self.len
class Testdataset(Dataset):
def __init__(self):
self.data=testfolds[i-1]
self.x_data=torch.from_numpy(np.asarray(self.data.iloc[:, 0:-1]))
self.len=self.data.shape[0]
self.y_data = torch.from_numpy(np.asarray(self.data.iloc[:, [-1]]))
if (use_cuda):
self.x_data = self.x_data.cuda()
self.y_data = self.y_data.cuda()
def __getitem__(self, index):
return self.x_data[index], self.y_data[index]
def __len__(self):
return self.len
traindataset = Traindataset()
testdataset = Testdataset()
testdataset_U = Testdataset() # Aggiunto, relativo agli UNLEARNED
header(model_lst,k,i,traindataset,testdataset)
#train_sampler,dev_sampler,test_sampler=dev_shuffle(shuffle_train,shuffle_test,val_split,traindataset,testdataset)
#train_sampler,dev_sampler,test_val_sampler,test_sampler=data_split(shuffle_train,shuffle_test,val_split,test_val_split,traindataset,testdataset)
#loaders
train_loader = torch.utils.data.DataLoader(traindataset, batch_size=batch_size,
sampler=train_sampler,drop_last=True)
test_val_loader = torch.utils.data.DataLoader(testdataset, batch_size=batch_size,
sampler=test_val_sampler,drop_last=True)
dev_loader = torch.utils.data.DataLoader(traindataset, batch_size=batch_size,
sampler=dev_sampler,drop_last=True)
# Questo l'ho cambiato da 'testdataset' a 'testdataset_U'
test_loader = torch.utils.data.DataLoader(testdataset_U, batch_size=batch_size,
sampler=test_sampler,drop_last=True)
modelClass = "Model" + str(k)
model = eval(modelClass)()
if (use_cuda):
model = model.cuda()
if doTrain:
criterion = nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr)
msg = 'Accuracy on test set before training: '+str(accuracy(test_loader, model))+'\n'
print(msg)
logfile.write(msg + "\n")
#EARLY STOP
epoch = 0
patience = 0
best_acc_dev=0
while (epoch<maxepoch and patience < maxpatience):
running_loss = 0.0
for l, data in enumerate(train_loader, 0):
inputs, labels = data
if use_cuda:
inputs, labels = inputs.cuda(), labels.cuda()
inputs, labels = Variable(inputs), Variable(labels)
y_pred = model(inputs)
if use_cuda:
y_pred = y_pred.cuda()
loss = criterion(y_pred, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss += loss.item()
#print accuracy ever l mini-batches
if l % 2000 == 1999:
msg = '[%d, %5d] loss: %.3f' %(epoch + 1, l + 1, running_loss / 999)
print(msg)
logfile.write(msg + "\n")
running_loss = 0.0
#msg = 'Accuracy on dev set:' + str(accuracy(dev_loader))
#print(msg)
#logfile.write(msg + "\n")
accdev = (accuracy(dev_loader, model))
msg = 'Accuracy on dev set:' + str(accdev)
print(msg)
logfile.write(msg + "\n")
is_best = bool(accdev > best_acc_dev)
best_acc_dev = (max(accdev, best_acc_dev))
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc_dev': best_acc_dev
}, is_best,os.path.join(folder,'F'+str(i)+'best.pth.tar'), logfile)
if is_best:
patience=0
else:
patience = patience+1
epoch = epoch+1
logfile.flush()
if doEval:
if use_cuda:
state = torch.load(os.path.join(folder,'F'+str(i)+'best.pth.tar'))
else:
state = torch.load(os.path.join(folder,'F'+str(i)+'best.pth.tar'), map_location=lambda storage, loc: storage)
stop_epoch = state['epoch']
model.load_state_dict(state['state_dict'])
if not use_cuda:
model.cpu()
accuracy_dev = state['best_acc_dev']
model.eval()
acctest = (accuracy(test_loader, model))
acctest_val = (accuracy(test_val_loader, model))
accs[i-1] = acctest
accs_test_val[i-1] = acctest_val
precision_0_U,recall_0_U,f1_score_0_U = pre_rec(test_loader, model, 0.0)
precisions_0_U[i-1] = precision_0_U
recalls_0_U[i-1] = recall_0_U
f1_scores_0_U[i-1] = f1_score_0_U
precision_1_U,recall_1_U,f1_score_1_U = pre_rec(test_loader, model, 1.0)
precisions_1_U[i-1] = precision_1_U
recalls_1_U[i-1] = recall_1_U
f1_scores_1_U[i-1] = f1_score_1_U
precision_0_L,recall_0_L,f1_score_0_L = pre_rec(test_val_loader, model, 0.0)
precisions_0_L[i-1] = precision_0_L
recalls_0_L[i-1] = recall_0_L
f1_scores_0_L[i-1] = f1_score_0_L
precision_1_L,recall_1_L,f1_score_1_L = pre_rec(test_val_loader, model, 1.0)
precisions_1_L[i-1] = precision_1_L
recalls_1_L[i-1] = recall_1_L
f1_scores_1_L[i-1] = f1_score_1_L
accs_dev[i-1] = accuracy_dev
writer.writerow({'Fold': i,'Acc_L': acctest_val, 'Acc_U': acctest,
#'P_0_U': precision_0_U,'R_0_U': recall_0_U,'F1_0_U': f1_score_0_U,
'R_0_U': recall_0_U,
#'P_1_U': precision_1_U,'R_1_U': recall_1_U,'F1_1_U': f1_score_1_U,
'R_1_U': recall_1_U,
#'P_0_L': precision_0_L,'R_0_L': recall_0_L,'F1_0_L': f1_score_0_L,
'R_0_L': recall_0_L,
#'P_1_L': precision_1_L,'R_1_L': recall_1_L,'F1_1_L': f1_score_1_L,
'R_1_L': recall_1_L,
'Stop_epoch': stop_epoch,'Accuracy_dev': accuracy_dev})
table.column_headers = fieldnames
table.append_row([i,acctest_val,acctest,
#precision_0_U,recall_0_U,f1_score_0_U,
recall_0_U,
#precision_1_U,recall_1_U,f1_score_1_U,
recall_1_U,
#precision_0_L,recall_0_L,f1_score_0_L,
recall_0_L,
#precision_1_L,recall_1_L,f1_score_1_L,
recall_1_L,
stop_epoch,accuracy_dev])
print(table)
print('----------------------------------------------------------------------')
logfile.write(str(table) + "\n----------------------------------------------------------------------\n")
t1 = time.time()
times[i-1] = int(t1-t0)
duration = str(datetime.timedelta(seconds=np.sum(times)))
writer.writerow({})
writer.writerow({'Fold': 'Elapsed time: '+duration})
avg_acc_test_val = round(np.average(accs_test_val),3)
std_acc_test_val = round(np.std(accs_test_val),3)
avg_acc_test_val,avg_a,avg_p_0_U,avg_r_0_U,avg_f_0_U,avg_p_1_U,avg_r_1_U,avg_f_1_U,avg_p_0_L,avg_r_0_L,avg_f_0_L,avg_p_1_L,avg_r_1_L,avg_f_1_L,avg_a_d=averages([accs_test_val,accs,precisions_0_U,recalls_0_U,f1_scores_0_U,precisions_1_U,recalls_1_U,f1_scores_1_U,precisions_0_L,recalls_0_L,f1_scores_0_L,precisions_1_L,recalls_1_L,f1_scores_1_L,accs_dev])
std_acc_test_val,std_a,std_p_0_U,std_r_0_U,std_f_0_U,std_p_1_U,std_r_1_U,std_f_1_U,std_p_0_L,std_r_0_L,std_f_0_L,std_p_1_L,std_r_1_L,std_f_1_L,std_a_d=stds([accs_test_val,accs,precisions_0_U,recalls_0_U,f1_scores_0_U,precisions_1_U,recalls_1_U,f1_scores_1_U,precisions_0_L,recalls_0_L,f1_scores_0_L,precisions_1_L,recalls_1_L,f1_scores_1_L,accs_dev])
writer1.writerow({model_lst[k]: 'Acc_U','Avg': avg_a,'Std_dev': std_acc_test_val})
writer1.writerow({model_lst[k]: 'Acc_L','Avg': avg_acc_test_val,'Std_dev': std_a})
writer1.writerow({model_lst[k]: 'P_0_U','Avg': avg_p_0_U ,'Std_dev': std_p_0_U})
writer1.writerow({model_lst[k]: 'R_0_U','Avg': avg_r_0_U,'Std_dev': std_r_0_U})
writer1.writerow({model_lst[k]: 'F1_0_U','Avg': avg_f_0_U,'Std_dev': std_f_0_U})
writer1.writerow({model_lst[k]: 'P_1_U','Avg': avg_p_1_U,'Std_dev': std_p_1_U})
writer1.writerow({model_lst[k]: 'R_1_U','Avg': avg_r_1_U,'Std_dev': std_r_1_U})
writer1.writerow({model_lst[k]: 'F1_1_U','Avg': avg_f_1_U,'Std_dev': std_f_1_U})
writer1.writerow({model_lst[k]: 'P_0_L','Avg': avg_p_0_L,'Std_dev': std_p_0_L})
writer1.writerow({model_lst[k]: 'R_0_L','Avg': avg_r_0_L,'Std_dev': std_r_0_L})
writer1.writerow({model_lst[k]: 'F1_0_L','Avg': avg_f_0_L,'Std_dev': std_f_0_L})
writer1.writerow({model_lst[k]: 'P_1_L','Avg': avg_p_1_L,'Std_dev': std_p_1_L})
writer1.writerow({model_lst[k]: 'R_1_L','Avg': avg_r_1_L,'Std_dev': std_r_1_L})
writer1.writerow({model_lst[k]: 'F1_1_L','Avg': avg_f_1_L,'Std_dev': std_f_1_L})
writer1.writerow({model_lst[k]: 'Acc_dev','Avg': avg_a_d,'Std_dev': std_a_d})
writer1.writerow({})
writer1.writerow({model_lst[k]: 'Elapsed time: '+duration})
avgtable.column_headers = fieldnames1
avgtable.append_row(['Acc_U',avg_a,std_a])
avgtable.append_row(['Acc_L',avg_acc_test_val,std_acc_test_val])
avgtable.append_row(['P_0_U',avg_p_0_U,std_p_0_U])
avgtable.append_row(['R_0_U',avg_r_0_U,std_r_0_U])
avgtable.append_row(['F1_0_U',avg_f_0_U,std_f_0_U])
avgtable.append_row(['P_1_U',avg_p_1_U,std_p_1_U])
avgtable.append_row(['R_1_U',avg_r_1_U,std_r_1_U])
avgtable.append_row(['F1_1_U',avg_f_1_U,std_f_1_U])
avgtable.append_row(['P_0_L',avg_p_0_L,std_p_0_L])
avgtable.append_row(['R_0_L',avg_r_0_L,std_r_0_L])
avgtable.append_row(['F1_0_L',avg_f_0_L,std_f_0_L])
avgtable.append_row(['P_1_L',avg_p_1_L,std_p_1_L])
avgtable.append_row(['R_1_L',avg_r_1_L,std_r_1_L])
avgtable.append_row(['F1_1_L',avg_f_1_L,std_f_1_L])
avgtable.append_row(['Accuracy_dev',avg_a_d,std_a_d])
print(avgtable)
logfile.write(str(avgtable) + "\n")
msg = 'Elapsed time: '+ duration + '\n\n'
print(msg)
logfile.write(msg )
logfile.close()
def delete_person(file_path):
parser = argparse.ArgumentParser()
parser.add_argument('--image_folder', type=str, default='data/samples', help='path to dataset')
parser.add_argument('--config_path', type=str, default='config/yolov3.cfg', help='path to model config file')
parser.add_argument('--weights_path', type=str, default='weights/yolov3.weights', help='path to weights file')
parser.add_argument('--class_path', type=str, default='data/coco.names', help='path to class label file')
parser.add_argument('--conf_thres', type=float, default=0.8, help='object confidence threshold')
parser.add_argument('--nms_thres', type=float, default=0.4, help='iou thresshold for non-maximum suppression')
parser.add_argument('--batch_size', type=int, default=1, help='size of the batches')
parser.add_argument('--n_cpu', type=int, default=8, help='number of cpu threads to use during batch generation')
parser.add_argument('--img_size', type=int, default=416, help='size of each image dimension')
parser.add_argument('--use_cuda', type=bool, default=True, help='whether to use cuda if available')
opt = parser.parse_args()
print(opt)
cuda = torch.cuda.is_available() and opt.use_cuda
os.makedirs('output', exist_ok=True)
# Set up model
model = Darknet(opt.config_path, img_size=opt.img_size)
model.load_weights(opt.weights_path)
if cuda:
model.cuda()
model.eval() # Set in evaluation mode
dataloader = DataLoader(ImageFolder(file_path, img_size=opt.img_size),
batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_cpu)
classes = load_classes(opt.class_path) # Extracts class labels from file
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
imgs = [] # Stores image paths
img_detections = [] # Stores detections for each image index
print ('\nPerforming object detection:')
prev_time = time.time()
for batch_i, (img_paths, input_imgs) in enumerate(dataloader):
# Configure input
input_imgs = Variable(input_imgs.type(Tensor))
# Get detections
with torch.no_grad():
detections = model(input_imgs)
detections = non_max_suppression(detections, 80, opt.conf_thres, opt.nms_thres)
# Log progress
current_time = time.time()
inference_time = datetime.timedelta(seconds=current_time - prev_time)
prev_time = current_time
print('\t Thread %d Batch %d, Inference Time: %s' % (threading.get_ident(), batch_i, inference_time))
# Save image and detections
imgs.extend(img_paths[0])
img_detections.extend(detections)
if detections[0] is not None:
for detection in detections:
x1, y1, x2, y2, conf, cls_conf, cls_pred = detection.numpy()[0,:]
print ('\t+ Label: %s, Conf: %.5f' % (classes[int(cls_pred)], cls_conf.item()))
if classes[int(cls_pred)] == 'person' and cls_conf.item() > 0.7 and abs(y2-y1) >= 128:
os.remove(img_paths[0])
print('delete')
break
# delete_person(file_path="/Users/rl/Desktop/data 2/wild/desert/sand")
# delete_person(file_path="data/samples")
from torch.autograd import Variable
class TwoLayerNet(torch.nn.Module):
def __init__(self, D_in, H, D_out):
super(TwoLayerNet, self).__init__()
self.linear1 = torch.nn.Linear(D_in, H)
self.linear2 = torch.nn.Linear(H, D_out)
def forward(self, x):
h_relu = self.linear1(x).clamp(min=0)
y_pred = self.linear2(h_relu)
return y_pred
N, D_in, H, D_out = 64, 1000, 100, 10
x = Variable(torch.randn(N, D_in))
y = Variable(torch.randn(N, D_out), requires_grad=False)
model = TwoLayerNet(D_in, H, D_out)
loss_fn = torch.nn.MSELoss(size_average=False)
optimizer = torch.optim.SGD(model.parameters(), lr=le - 4)
for i in range(500):
y_pred = model(x)
loss = loss_fn(y_pred, y)
print(i, loss.data[0])
optimizer.zero_grad()
loss.backward()
optimizer.step()
def linearize_dynamics(self, x, u, dynamics, diff):
# TODO: Cleanup variable usage.
n_batch = x[0].shape[0]
if self.grad_method == GradMethods.ANALYTIC:
_u = u[:-1].reshape(-1, self.n_ctrl)
_x = x[:-1].reshape(-1, self.n_state)
# This inefficiently calls dynamics again, but is worth it because
# we can efficiently compute grad_input for every time step at once.
_new_x = dynamics(_x, _u)
# This check is a little expensive and should only be done if
# modifying this code.
# assert torch.abs(_new_x.data - x[1:].view(-1, self.n_state)).max() <= 1e-6
# if not diff:
# _new_x = _new_x.data
# _x = _x.data
# _u = _u.data
R, S = dynamics.grad_input(_x, _u)
f = _new_x - util.bmv(R, _x) - util.bmv(S, _u)
f = f.reshape(self.T-1, n_batch, self.n_state)
R = R.reshape(self.T-1, n_batch, self.n_state, self.n_state)
S = S.reshape(self.T-1, n_batch, self.n_state, self.n_ctrl)
F = np.concatenate((R, S), 3)
return F, f
else:
# TODO: This is inefficient and confusing.
x_init = x[0]
x = [x_init]
F, f = [], []
for t in range(self.T):
if t < self.T-1:
xt = Variable(x[t], requires_grad=True)
ut = Variable(u[t], requires_grad=True)
xut = torch.cat((xt, ut), 1)
new_x = dynamics(xt, ut)
# Linear dynamics approximation.
if self.grad_method in [GradMethods.AUTO_DIFF,
GradMethods.ANALYTIC_CHECK]:
Rt, St = [], []
for j in range(self.n_state):
Rj, Sj = torch.autograd.grad(
new_x[:,j].sum(), [xt, ut],
retain_graph=True)
if not diff:
Rj, Sj = Rj.data, Sj.data
Rt.append(Rj)
St.append(Sj)
Rt = torch.stack(Rt, dim=1)
St = torch.stack(St, dim=1)
if self.grad_method == GradMethods.ANALYTIC_CHECK:
assert False # Not updated
Rt_autograd, St_autograd = Rt, St
Rt, St = dynamics.grad_input(xt, ut)
eps = 1e-8
if torch.max(torch.abs(Rt-Rt_autograd)).data[0] > eps or \
torch.max(torch.abs(St-St_autograd)).data[0] > eps:
print('''
nmpc.ANALYTIC_CHECK error: The analytic derivative of the dynamics function may be off.
''')
else:
print('''
nmpc.ANALYTIC_CHECK: The analytic derivative of the dynamics function seems correct.
Re-run with GradMethods.ANALYTIC to continue.
''')
sys.exit(0)
elif self.grad_method == GradMethods.FINITE_DIFF:
Rt, St = [], []
for i in range(n_batch):
Ri = util.jacobian(
lambda s: dynamics(s, ut[i]), xt[i], 1e-3
)
Si = util.jacobian(
lambda a : dynamics(xt[i], a), ut[i], 1e-3
)
if not diff:
Ri, Si = Ri.data, Si.data
Rt.append(Ri)
St.append(Si)
Rt = torch.stack(Rt)
St = torch.stack(St)
Rt = Rt.squeeze(0)
St = St.squeeze(0)
else:
assert False
Ft = torch.cat((Rt, St), 2)
F.append(Ft)
if not diff:
xt, ut, new_x = xt.data, ut.data, new_x.data
ft = new_x - util.bmv(Rt, xt) - util.bmv(St, ut)
f.append(ft)
if t < self.T-1:
x.append(util.detach_maybe(new_x))
F = torch.stack(F, 0)
f = torch.stack(f, 0)
if not diff:
F, f = list(map(Variable, [F, f]))
return F, f
numExamples = instances.shape[1]
dtype = torch.FloatTensor
ltype = torch.ByteTensor
##======================================================================
## STEP 2: Initialize parameters, set them up as Variables for autograd.
#
# Instructions: Initialize W with a standard Gaussian * 0.01
# Compute the groundTruth matrix, set as a variable.
# Randomly initialize parameters W and b.
groundTruth = coo_matrix((np.ones(numExamples, dtype = np.uint8),
(labels, np.arange(numExamples)))).toarray()
groundTruth = Variable(torch.Tensor(groundTruth))
W = torch.Tensor(numClasses, inputSize).normal_() * 0.01
W = Variable(W, requires_grad = True)
b = torch.Tensor(numClasses, 1).fill_(0)
b = Variable(b, requires_grad = True)
# Load training data into Variables that do not require gradients.
instances = Variable(torch.Tensor(instances))
labels = Variable(torch.Tensor(labels).type(ltype))
## ----------------------------------------------------------------
# Set hyper-parameters.
learning_rate = 1.0
decay = 0.001
num_epochs = 200
def make_std_mask(tgt, pad):
"Create a mask to hide padding and future words"
tgt_mask = (tgt != pad).unsqueeze(-2)
tgt_mask = tgt_mask & Variable(
subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))
return tgt_mask
def forward(self, x_init, cost, dx):
# QuadCost.C: [T, n_batch, n_tau, n_tau]
# QuadCost.c: [T, n_batch, n_tau]
assert isinstance(cost, QuadCost) or \
isinstance(cost, Module) or isinstance(cost, Function)
assert isinstance(dx, LinDx) or \
isinstance(dx, Module) or isinstance(dx, Function)
# TODO: Clean up inferences, expansions, and assumptions made here.
if self.n_batch is not None:
n_batch = self.n_batch
elif isinstance(cost, QuadCost) and cost.C.ndim == 4:
n_batch = cost.C.shape[1]
else:
print('MPC Error: Could not infer batch size, pass in as n_batch')
sys.exit(-1)
# if c.ndimension() == 2:
# c = c.unsqueeze(1).expand(self.T, n_batch, -1)
if isinstance(cost, QuadCost):
C, c = cost
if C.ndim == 2:
# Add the time and batch dimensions.
C = np.tile(C, (self.T, n_batch, 1, 1))
elif C.ndim == 3:
# Add the batch dimension.
C = np.tile(np.expand_dims(C, 1), (1, n_batch, 1, 1))
if c.ndim == 1:
# Add the time and batch dimensions.
c = np.tile(c, (self.T, n_batch, 1))
elif c.ndim == 2:
# Add the batch dimension.
c = np.tile(np.expand_dims(c, 1), (1, n_batch, 1))
if C.ndim != 4 or c.ndim != 3:
print('MPC Error: Unexpected QuadCost shape.')
sys.exit(-1)
cost = QuadCost(C, c)
assert x_init.ndim == 2 and x_init.shape[0] == n_batch
if self.u_init is None:
u = np.zeros((self.T, n_batch, self.n_ctrl), dtype='single')
else:
u = self.u_init
if u.ndim == 2:
u = np.tile(np.expand_dims(u, 1), (1, n_batch, 1))
if self.verbose > 0:
print('Initial mean(cost): {:.4e}'.format(
np.mean(util.get_cost(
self.T, u, cost, dx, x_init=x_init
))
))
best = None
n_not_improved = 0
for i in range(self.lqr_iter):
u = u
# Linearize the dynamics around the current trajectory.
# time3 = time.time()
# print('begin get traj')
x = util.get_traj(self.T, u, x_init=x_init, dynamics=dx)
# print('end get traj')
# time4 = time.time()
# print('get trajectory time:', time4 - time3)
if isinstance(dx, LinDx):
F, f = dx.F, dx.f
else:
# start = time.time()
F, f = self.linearize_dynamics(
x, u, dx, diff=False)
# end = time.time()
# print('dynamics linearize:',end-start)
if isinstance(cost, QuadCost):
C, c = cost.C, cost.c
else:
C, c, _ = self.approximate_cost(
x, u, cost, diff=False)
x, u, _lqr = self.solve_lqr_subproblem(
x_init, C, c, F, f, cost, dx, x, u, self.verbose)
# print(u)
back_out, for_out = _lqr.back_out, _lqr.for_out
n_not_improved += 1
assert x.ndim == 3
assert u.ndim == 3
if best is None:
best = {
'x': list(np.split(x, indices_or_sections=1, axis=1)),
'u': list(np.split(u, indices_or_sections=1, axis=1)),
'costs': for_out.costs,
# 'costsxx': for_out.costsxx,
# 'costsuu': for_out.costsuu,
# 'costsx': for_out.costsx,
# 'costsu': for_out.costsu,
# 'objsxx': for_out.objsxx,
# 'objsuu': for_out.objsuu,
# 'objsx': for_out.objsx,
# 'objsu': for_out.objsu,
'full_du_norm': for_out.full_du_norm,
}
else:
for j in range(n_batch):
if for_out.costs[j] <= best['costs'][j] - self.best_cost_eps:
n_not_improved = 0
best['x'][j] = np.expand_dims(x[:,j], 1)
best['u'][j] = np.expand_dims(u[:,j], 1)
best['costs'][j] = for_out.costs[j]
# best['costsxx'][j] = for_out.costsxx[j]
# best['costsuu'][j] = for_out.costsuu[j]
# best['costsx'][j] = for_out.costsx[j]
# best['costsu'][j] = for_out.costsu[j]
# best['objsxx'][:,j] = for_out.objsxx[:,j]
# best['objsuu'][:,j] = for_out.objsuu[:,j]
# best['objsx'][:,j] = for_out.objsx[:,j]
# best['objsu'][:,j] = for_out.objsu[:,j]
best['full_du_norm'][j] = for_out.full_du_norm[j]
if self.verbose > 0:
util.table_log('lqr', (
('iter', i),
('mean(cost)', np.mean(best['costs']).item(), '{:.4e}'),
('mean(costxx)', np.mean(best['costsxx']).item(), '{:.4e}'),
('mean(costuu)', np.mean(best['costsuu']).item(), '{:.4e}'),
# ('mean(costx)', np.mean(best['costsx']).item(), '{:.4e}'),
# ('mean(costu)', np.mean(best['costsu']).item(), '{:.4e}'),
('mean(objsxx[0])', np.mean(best['objsxx'][0], ).item(), '{:.4e}'),
('mean(objsuu[0])', np.mean(best['objsuu'][0], ).item(), '{:.4e}'),
('mean(objsxx[1])', np.mean(best['objsxx'][1], ).item(), '{:.4e}'),
('mean(objsuu[1])', np.mean(best['objsuu'][1], ).item(), '{:.4e}'),
('mean(objsxx[2])', np.mean(best['objsxx'][2], ).item(), '{:.4e}'),
('mean(objsuu[2])', np.mean(best['objsuu'][2], ).item(), '{:.4e}'),
('mean(objsxx[3])', np.mean(best['objsxx'][3], ).item(), '{:.4e}'),
('mean(objsuu[3])', np.mean(best['objsuu'][3], ).item(), '{:.4e}'),
# ('mean(objsxx[4])', np.mean(best['objsxx'][4], ).item(), '{:.4e}'),
# ('mean(objsuu[4])', np.mean(best['objsuu'][4], ).item(), '{:.4e}'),
# ('||full_du||_max', max(for_out.full_du_norm).item(), '{:.2e}'),
# ('||alpha_du||_max', max(for_out.alpha_du_norm), '{:.2e}'),
# TODO: alphas, total_qp_iters here is for the current
# iterate, not the best
# ('mean(alphas)', for_out.mean_alphas.item(), '{:.2e}'),
# ('total_qp_iters', back_out.n_total_qp_iter),
))
if max(for_out.full_du_norm) < self.eps or \
n_not_improved > self.not_improved_lim:
break
x = np.concatenate(best['x'], axis=1)
u = np.concatenate(best['u'], axis=1)
full_du_norm = best['full_du_norm']
# if isinstance(dx, LinDx):
# F, f = dx.F, dx.f
# else:
# time1 = time.time()
# F, f = self.linearize_dynamics(x, u, dx, diff=True)
# time2 = time.time()
# print('dynamics linearize2:', time2 - time1)
#
# if isinstance(cost, QuadCost):
# C, c = cost.C, cost.c
# else:
# C, c, _ = self.approximate_cost(x, u, cost, diff=True)
#
# x, u, _ = self.solve_lqr_subproblem(
# x_init, C, c, F, f, cost, dx, x, u, no_op_forward=True)
if self.detach_unconverged:
if max(best['full_du_norm']) > self.eps:
if self.exit_unconverged:
assert False
if self.verbose >= 0:
print("LQR Warning: All examples did not converge to a fixed point.")
print("Detaching and *not* backpropping through the bad examples.")
I = for_out.full_du_norm < self.eps
Ix = Variable(I.unsqueeze(0).unsqueeze(2).expand_as(x)).type_as(x.data)
Iu = Variable(I.unsqueeze(0).unsqueeze(2).expand_as(u)).type_as(u.data)
x = x*Ix + x.clone().detach()*(1.-Ix)
u = u*Iu + u.clone().detach()*(1.-Iu)
costs = best['costs']
return (x, u, costs)
def init_hidden(self, bsz):
weight = next(self.parameters()).data
return (Variable(weight.new(self.layers_num, bsz, self.hidden_dim).zero_()),
Variable(weight.new(self.layers_num, bsz, self.hidden_dim).zero_()))
testloader = DataLoader(testset,
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_workers)
print('[INFO] testloader generated')
probs_list = []
labels_list = []
rsids_list = []
query_snp_rsids_list = []
for data in tqdm(testloader):
inputs1, inputs2, inputs3, inputs4, labels, rsids, query_snp_rsids, metadata = data
if torch.cuda.is_available():
inputs1, inputs2, inputs3, inputs4, labels, metadata = Variable(
inputs1.cuda()), Variable(inputs2.cuda()), Variable(
inputs3.cuda()), Variable(inputs4.cuda()), Variable(
labels.cuda()), Variable(metadata.cuda())
else:
inputs1, inputs2, inputs3, inputs4, labels, metadata = Variable(
inputs1), Variable(inputs2), Variable(inputs3), Variable(
inputs4), Variable(labels), Variable(metadata)
outputs = model(inputs1, inputs2, inputs3, inputs4, metadata)
_, preds = torch.max(outputs.data, 1)
probs = F.softmax(outputs, 1)
correct += torch.sum(preds == labels.data)
tp += torch.sum((preds + labels.data) == 2)
size += len(labels)
probs_list.extend(probs.data[:, 1])
def init_hidden(self):
"""Initialize hidden state"""
return (Variable(torch.zeros(1, 128, self.hidden_size)),
Variable(torch.zeros(1, 128, self.hidden_size)))
def _runnetwork(epoch, loader, train=True, scaler=None, pbar=None):
global nb_update_network
# net
if train:
net.train()
else:
net.eval()
if train:
optimizer.zero_grad()
for batch_idx, targets in enumerate(loader):
data = Variable(targets['image'].cuda())
with amp.autocast():
output_belief, output_affinities = net(data)
target_belief = Variable(targets['beliefs'].cuda())
target_affinity = Variable(targets['affinities'].cuda())
loss = None
# Belief maps loss
for l in output_belief: #output, each belief map layers.
if loss is None:
loss = ((l - target_belief) * (l-target_belief)).mean()
else:
loss_tmp = ((l - target_belief) * (l-target_belief)).mean()
loss += loss_tmp
# Affinities loss
for l in output_affinities: #output, each belief map layers.
loss_tmp = ((l - target_affinity) * (l-target_affinity)).mean()
loss += loss_tmp
if train:
scaler.scale(loss).backward()
if batch_idx % (opt.batchsize // opt.subbatchsize) == 0:
if train:
scaler.step(optimizer)
scaler.update()
nb_update_network+=1
optimizer.zero_grad()
if train:
namefile = '/loss_train.csv'
else:
namefile = '/loss_test.csv'
with open (opt.outf+namefile,'a') as file:
s = '{}, {},{:.15f}\n'.format(
epoch,batch_idx,loss.data.item())
# print (s)
file.write(s)
# break
if not opt.nbupdates is None and nb_update_network > int(opt.nbupdates):
torch.save(net.state_dict(), '{}/net_{}.pth'.format(opt.outf, opt.namefile))
break
if train:
if pbar is not None:
pbar.set_description("Training loss: %0.4f (%d/%d)" % (loss.data.item(), batch_idx, len(loader)))
else:
if pbar is not None:
pbar.set_description("Testing loss: %0.4f (%d/%d)" % (loss.data.item(), batch_idx, len(loader)))
if train:
optimizer.zero_grad()
def to_var(x, volatile=False):
if torch.cuda.is_available():
x = x.cuda()
return Variable(x, volatile=volatile)
def test(args, shared_model):
log = {}
logger = setup_logger("test_log", "./logs/test_log")
torch.manual_seed(args.seed)
env = Tetris(50)
model = agentNET()
model.eval()
test_time = 0
reward_num = 0
clean_sum = 0
max_reward = -1
while (1):
model.load_state_dict(shared_model.state_dict())
if args.gpu:
model = model.cuda()
cx = Variable(torch.zeros(1, 78).cuda())
hx = Variable(torch.zeros(1, 78).cuda())
else:
cx = Variable(torch.zeros(1, 78))
hx = Variable(torch.zeros(1, 78))
state = env.reset() #50 100 3
state = torch.from_numpy(state).float()
while (1):
if args.gpu:
value, logit, (hx, cx) = model(
(Variable(state.unsqueeze(0)).cuda(), (hx, cx)))
else:
value, logit, (hx, cx) = model(
(Variable(state.unsqueeze(0)), (hx, cx)))
prob = F.softmax(logit)
if args.gpu:
action = prob.max(1)[1].data.cpu()
else:
action = prob.max(1)[1].data
state, done, reward, clean = env.step(action.numpy()[0])
state = torch.from_numpy(state).float()
reward_num += reward
clean_sum += clean.get('1', -1000)
if done:
#print('dead', test_time)
test_time += 1
break
if test_time % 50 == 0:
if reward_num > max_reward:
if args.gpu:
model = model.cpu()
state_to_save = model.state_dict()
torch.save(state_to_save, "./tetris.dat")
logger.info('save')
max_reward = reward_num
if args.gpu:
model = model.cuda()
logger.info('reward = ' + str(reward_num / test_time))
logger.info('cleaned = ' + str(clean_sum / test_time))
test_time = 0
reward_num = 0
clean_sum = 0
def forward(self, left, right):
refimg_fea = self.feature_extraction(left)
targetimg_fea = self.feature_extraction(right)
#matching
cost = Variable(
torch.FloatTensor(refimg_fea.size()[0],
refimg_fea.size()[1] * 2, self.maxdisp / 4,
refimg_fea.size()[2],
refimg_fea.size()[3]).zero_()).cuda()
for i in range(int(self.maxdisp / 4)):
if i > 0:
cost[:, :refimg_fea.size()[1], i, :, i:] = refimg_fea[:, :, :,
i:]
cost[:, refimg_fea.size()[1]:, i, :,
i:] = targetimg_fea[:, :, :, :-i]
else:
cost[:, :refimg_fea.size()[1], i, :, :] = refimg_fea
cost[:, refimg_fea.size()[1]:, i, :, :] = targetimg_fea
cost = cost.contiguous()
cost0 = self.dres0(cost)
cost0 = self.dres1(cost0) + cost0
out1, pre1, post1 = self.dres2(cost0, None, None)
out1 = out1 + cost0
out2, pre2, post2 = self.dres3(out1, pre1, post1)
out2 = out2 + cost0
out3, pre3, post3 = self.dres4(out2, pre1, post2)
out3 = out3 + cost0
cost1 = self.classif1(out1)
cost2 = self.classif2(out2) + cost1
cost3 = self.classif3(out3) + cost2
if self.training:
cost1 = F.upsample(
cost1,
[self.maxdisp, left.size()[2],
left.size()[3]],
mode='trilinear')
cost2 = F.upsample(
cost2,
[self.maxdisp, left.size()[2],
left.size()[3]],
mode='trilinear')
cost1 = torch.squeeze(cost1, 1)
pred1 = F.softmax(cost1, dim=1)
pred1 = disparityregression(self.maxdisp)(pred1)
cost2 = torch.squeeze(cost2, 1)
pred2 = F.softmax(cost2, dim=1)
pred2 = disparityregression(self.maxdisp)(pred2)
cost3 = F.upsample(
cost3, [self.maxdisp, left.size()[2],
left.size()[3]],
mode='trilinear')
cost3 = torch.squeeze(cost3, 1)
pred3 = F.softmax(cost3, dim=1)
pred3 = disparityregression(self.maxdisp)(pred3)
if self.training:
return pred1, pred2, pred3
else:
return pred3
def siamese_track(state,
im,
mask_enable=False,
refine_enable=False,
device='cpu',
debug=False):
p = state['p']
net = state['net']
avg_chans = state['avg_chans']
window = state['window']
target_pos = state['target_pos']
target_sz = state['target_sz']
wc_x = target_sz[1] + p.context_amount * sum(target_sz)
hc_x = target_sz[0] + p.context_amount * sum(target_sz)
s_x = np.sqrt(wc_x * hc_x)
scale_x = p.exemplar_size / s_x
d_search = (p.instance_size - p.exemplar_size) / 2
pad = d_search / scale_x
s_x = s_x + 2 * pad
crop_box = [
target_pos[0] - round(s_x) / 2, target_pos[1] - round(s_x) / 2,
round(s_x),
round(s_x)
]
if debug:
im_debug = im.copy()
crop_box_int = np.int0(crop_box)
cv2.rectangle(im_debug, (crop_box_int[0], crop_box_int[1]),
(crop_box_int[0] + crop_box_int[2],
crop_box_int[1] + crop_box_int[3]), (255, 0, 0), 2)
cv2.imshow('search area', im_debug)
cv2.waitKey(0)
# extract scaled crops for search region x at previous target position
x_crop = Variable(
get_subwindow_tracking(im, target_pos, p.instance_size, round(s_x),
avg_chans).unsqueeze(0))
if mask_enable:
score, delta, mask = net.track_mask(x_crop.to(device))
else:
score, delta = net.track(x_crop.to(device))
delta = delta.permute(1, 2, 3, 0).contiguous().view(4,
-1).data.cpu().numpy()
score = F.softmax(score.permute(1, 2, 3,
0).contiguous().view(2, -1).permute(1, 0),
dim=1).data[:, 1].cpu().numpy()
delta[0, :] = delta[0, :] * p.anchor[:, 2] + p.anchor[:, 0]
delta[1, :] = delta[1, :] * p.anchor[:, 3] + p.anchor[:, 1]
delta[2, :] = np.exp(delta[2, :]) * p.anchor[:, 2]
delta[3, :] = np.exp(delta[3, :]) * p.anchor[:, 3]
def change(r):
return np.maximum(r, 1. / r)
def sz(w, h):
pad = (w + h) * 0.5
sz2 = (w + pad) * (h + pad)
return np.sqrt(sz2)
def sz_wh(wh):
pad = (wh[0] + wh[1]) * 0.5
sz2 = (wh[0] + pad) * (wh[1] + pad)
return np.sqrt(sz2)
# size penalty
target_sz_in_crop = target_sz * scale_x
s_c = change(sz(delta[2, :], delta[3, :]) /
(sz_wh(target_sz_in_crop))) # scale penalty
r_c = change((target_sz_in_crop[0] / target_sz_in_crop[1]) /
(delta[2, :] / delta[3, :])) # ratio penalty
penalty = np.exp(-(r_c * s_c - 1) * p.penalty_k)
pscore = penalty * score
# cos window (motion model)
pscore = pscore * (1 - p.window_influence) + window * p.window_influence
best_pscore_id = np.argmax(pscore)
pred_in_crop = delta[:, best_pscore_id] / scale_x
lr = penalty[best_pscore_id] * score[best_pscore_id] * p.lr # lr for OTB
res_x = pred_in_crop[0] + target_pos[0]
res_y = pred_in_crop[1] + target_pos[1]
res_w = target_sz[0] * (1 - lr) + pred_in_crop[2] * lr
res_h = target_sz[1] * (1 - lr) + pred_in_crop[3] * lr
target_pos = np.array([res_x, res_y])
target_sz = np.array([res_w, res_h])
# for Mask Branch
if mask_enable:
best_pscore_id_mask = np.unravel_index(best_pscore_id,
(5, p.score_size, p.score_size))
delta_x, delta_y = best_pscore_id_mask[2], best_pscore_id_mask[1]
if refine_enable:
mask = net.track_refine(
(delta_y, delta_x)).to(device).sigmoid().squeeze().view(
p.out_size, p.out_size).cpu().data.numpy()
else:
mask = mask[0, :, delta_y, delta_x].sigmoid(). \
squeeze().view(p.out_size, p.out_size).cpu().data.numpy()
def crop_back(image, bbox, out_sz, padding=-1):
a = (out_sz[0] - 1) / bbox[2]
b = (out_sz[1] - 1) / bbox[3]
c = -a * bbox[0]
d = -b * bbox[1]
mapping = np.array([[a, 0, c], [0, b, d]]).astype(np.float)
crop = cv2.warpAffine(image,
mapping, (out_sz[0], out_sz[1]),
flags=cv2.INTER_LINEAR,
borderMode=cv2.BORDER_CONSTANT,
borderValue=padding)
return crop
s = crop_box[2] / p.instance_size
sub_box = [
crop_box[0] + (delta_x - p.base_size / 2) * p.total_stride * s,
crop_box[1] + (delta_y - p.base_size / 2) * p.total_stride * s,
s * p.exemplar_size, s * p.exemplar_size
]
s = p.out_size / sub_box[2]
back_box = [
-sub_box[0] * s, -sub_box[1] * s, state['im_w'] * s,
state['im_h'] * s
]
mask_in_img = crop_back(mask, back_box, (state['im_w'], state['im_h']))
target_mask = (mask_in_img > p.seg_thr).astype(np.uint8)
if cv2.__version__[-5] == '4':
contours, _ = cv2.findContours(target_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
else:
_, contours, _ = cv2.findContours(target_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
cnt_area = [cv2.contourArea(cnt) for cnt in contours]
if len(contours) != 0 and np.max(cnt_area) > 100:
contour = contours[np.argmax(cnt_area)] # use max area polygon
polygon = contour.reshape(-1, 2)
# pbox = cv2.boundingRect(polygon) # Min Max Rectangle
prbox = cv2.boxPoints(
cv2.minAreaRect(polygon)) # Rotated Rectangle
# box_in_img = pbox
rbox_in_img = prbox
else: # empty mask
location = cxy_wh_2_rect(target_pos, target_sz)
rbox_in_img = np.array(
[[location[0], location[1]],
[location[0] + location[2], location[1]],
[location[0] + location[2], location[1] + location[3]],
[location[0], location[1] + location[3]]])
target_pos[0] = max(0, min(state['im_w'], target_pos[0]))
target_pos[1] = max(0, min(state['im_h'], target_pos[1]))
target_sz[0] = max(10, min(state['im_w'], target_sz[0]))
target_sz[1] = max(10, min(state['im_h'], target_sz[1]))
state['target_pos'] = target_pos
state['target_sz'] = target_sz
state['score'] = score[best_pscore_id]
state['mask'] = mask_in_img if mask_enable else []
state['ploygon'] = rbox_in_img if mask_enable else []
return state
def do_crf_inference(image, unary, args):
if args.pyinn or not hasattr(torch.nn.functional, 'unfold'):
# pytorch 0.3 or older requires pyinn.
args.pyinn = True
# Cheap and easy trick to make sure that pyinn is loadable.
import pyinn
# get basic hyperparameters
num_classes = unary.shape[2]
shape = image.shape[0:2]
config = convcrf.default_conf
config['filter_size'] = 7
config['pyinn'] = args.pyinn
if args.normalize:
# Warning, applying image normalization affects CRF computation.
# The parameter 'col_feats::schan' needs to be adapted.
# Normalize image range
# This changes the image features and influences CRF output
image = image / 255
# mean substraction
# CRF is invariant to mean subtraction, output is NOT affected
image = image - 0.5
# std normalization
# Affect CRF computation
image = image / 0.3
# schan = 0.1 is a good starting value for normalized images.
# The relation is f_i = image * schan
config['col_feats']['schan'] = 0.1
# make input pytorch compatible
image = image.transpose(2, 0, 1) # shape: [3, hight, width]
# Add batch dimension to image: [1, 3, height, width]
image = image.reshape([1, 3, shape[0], shape[1]])
img_var = Variable(torch.Tensor(image)).cuda()
unary = unary.transpose(2, 0, 1) # shape: [3, hight, width]
# Add batch dimension to unary: [1, 21, height, width]
unary = unary.reshape([1, num_classes, shape[0], shape[1]])
unary_var = Variable(torch.Tensor(unary)).cuda()
logging.info("Build ConvCRF.")
##
# Create CRF module
gausscrf = convcrf.GaussCRF(conf=config, shape=shape, nclasses=num_classes)
# Cuda computation is required.
# A CPU implementation of our message passing is not provided.
gausscrf.cuda()
logging.info("Start Computation.")
# Perform CRF inference
prediction = gausscrf.forward(unary=unary_var, img=img_var)
if args.nospeed:
# Evaluate inference speed
logging.info("Doing speed evaluation.")
start_time = time.time()
for i in range(10):
# Running ConvCRF 10 times and average total time
pred = gausscrf.forward(unary=unary_var, img=img_var)
pred.cpu() # wait for all GPU computations to finish
duration = (time.time() - start_time) * 1000 / 10
logging.info("Finished running 10 predictions.")
logging.info("Avg. Computation time: {} ms".format(duration))
return prediction.data.cpu().numpy()
def evaluate(src_sents, tgt_sents, src_seqs, tgt_seqs, src_lens, tgt_lens, rate_sents, cate_sents, senti_sents, encoder, decoder):
# -------------------------------------
# Prepare input and output placeholders
# -------------------------------------
# Last batch might not have the same size as we set to the `batch_size`
batch_size = src_seqs.size(1)
assert (batch_size == tgt_seqs.size(1))
# Pack tensors to variables for neural network inputs (in order to autograd)
src_seqs = Variable(src_seqs, volatile=True)
tgt_seqs = Variable(tgt_seqs, volatile=True)
# Categorize seq lengths
if opts.use_sent_len:
bins = range(0, opts.max_seq_len + 10, opts.use_sent_len)
src_len_cates = list(pd.cut(src_lens, bins, labels=range(len(bins) - 1)))
src_len_cates = Variable(torch.LongTensor(src_len_cates), volatile=True)
else:
src_len_cates = None
src_lens = Variable(torch.LongTensor(src_lens), volatile=True)
tgt_lens = Variable(torch.LongTensor(tgt_lens), volatile=True)
rate_sents = Variable(torch.LongTensor(rate_sents), volatile=True)
cate_sents = Variable(torch.LongTensor(cate_sents), volatile=True)
senti_sents = Variable(torch.LongTensor(senti_sents), volatile=True)
# Decoder's input
input_seq = Variable(torch.LongTensor([BOS] * batch_size), volatile=True)
# Decoder's output sequence length = max target sequence length of current batch.
max_tgt_len = tgt_lens.data.max()
# Store all decoder's outputs.
# **CRUTIAL**
# Don't set:
# >> decoder_outputs = Variable(torch.zeros(max_tgt_len, batch_size, decoder.vocab_size))
# Varying tensor size could cause GPU allocate a new memory causing OOM,
# so we intialize tensor with fixed size instead:
# `opts.max_seq_len` is a fixed number, unlike `max_tgt_len` always varys.
decoder_outputs = Variable(torch.zeros(opts.max_seq_len, batch_size, decoder.vocab_size), volatile=True)
# Move variables from CPU to GPU.
if USE_CUDA:
src_seqs = src_seqs.cuda()
tgt_seqs = tgt_seqs.cuda()
src_lens = src_lens.cuda()
tgt_lens = tgt_lens.cuda()
input_seq = input_seq.cuda()
rate_sents = rate_sents.cuda()
cate_sents = cate_sents.cuda()
if opts.use_sent_len:
src_len_cates = src_len_cates.cuda()
senti_sents = senti_sents.cuda()
decoder_outputs = decoder_outputs.cuda()
# -------------------------------------
# Evaluation mode (disable dropout)
# -------------------------------------
encoder.eval()
decoder.eval()
# -------------------------------------
# Forward encoder
# -------------------------------------
encoder_outputs, encoder_hidden = encoder(src_seqs, src_lens.data.tolist())
# -------------------------------------
# Forward decoder
# -------------------------------------
# Initialize decoder's hidden state as encoder's last hidden state.
decoder_hidden = encoder_hidden
# Run through decoder one time step at a time.
for t in range(max_tgt_len):
# decoder returns:
# - decoder_output : (batch_size, vocab_size)
# - decoder_hidden : (num_layers, batch_size, hidden_size)
# - attention_weights: (batch_size, max_src_len)
decoder_output, decoder_hidden, attention_weights = decoder(input_seq, decoder_hidden, encoder_outputs, src_lens, rate_sents, cate_sents, src_len_cates, senti_sents)
# Store decoder outputs.
decoder_outputs[t] = decoder_output
# Next input is current target
input_seq = tgt_seqs[t]
# Detach hidden state (may not need this, since no BPTT)
detach_hidden(decoder_hidden)
# -------------------------------------
# Compute loss
# -------------------------------------
loss, pred_seqs, num_corrects, num_words = masked_cross_entropy(
decoder_outputs[:max_tgt_len].transpose(0, 1).contiguous(),
tgt_seqs.transpose(0, 1).contiguous(),
tgt_lens
)
pred_seqs = pred_seqs[:max_tgt_len]
return loss.data.item(), pred_seqs, attention_weights, num_corrects, num_words
valset = MiniImageNet2('trainvaltest')
val_loader = DataLoader(dataset=valset, batch_size = 128,
num_workers=8, pin_memory=True)
valset2 = MiniImageNet2('trainval')
val_loader2 = DataLoader(dataset=valset2, batch_size = 128,
num_workers=8, pin_memory=True)
valset3 = MiniImageNet2('test')
val_loader3 = DataLoader(dataset=valset3, batch_size = 128,
num_workers=8, pin_memory=True)
model_cnn = Convnet().cuda()
model_cnn.load_state_dict(torch.load('./100way_pn_basenovel.pth'))
global_proto = torch.load('./global_proto_basenovel_PN_5shot_500.pth')
global_base =global_proto[:args.n_base_class,:]
global_novel = global_proto[args.n_base_class:,:]
global_base = [Variable(global_base.cuda(),requires_grad=True)]
global_novel = [Variable(global_novel.cuda(),requires_grad=True)]
def log(out_str):
print(out_str)
logfile.write(out_str+'\n')
logfile.flush()
model_cnn.eval()
for epoch in range(1, args.max_epoch + 1):
for i, batch in enumerate(val_loader, 1):
data, lab = [_.cuda() for _ in batch]
data_shot = data[:, 3:, :]
proto = model_cnn(data_shot)
state_dict['rnn.1.embedding.bias'] = torch.randn(class_count)
state_dict['rnn.1.embedding.weight'] = torch.randn(class_count, 512)
crnn.load_state_dict(state_dict)
print(crnn)
image = torch.FloatTensor(opt.batchSize, 3, opt.imgH, opt.imgH)
text = torch.IntTensor(opt.batchSize * 5)
length = torch.IntTensor(opt.batchSize)
if opt.cuda:
crnn.cuda()
crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
image = image.cuda()
criterion = criterion.cuda()
image = Variable(image)
text = Variable(text)
length = Variable(length)
# loss averager
loss_avg = utils.averager()
# setup optimizer
if opt.adam:
optimizer = optim.Adam(crnn.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
elif opt.adadelta:
optimizer = optim.Adadelta(crnn.parameters(), lr=opt.lr)
else:
optimizer = optim.RMSprop(crnn.parameters(), lr=opt.lr)
def __len__(self):
return len(self.data)
model = Net().cuda()
ceLoss = t.nn.CrossEntropyLoss()
opt = t.optim.Adam(model.parameters(), lr=0.001)
#trainDataset = tv.datasets.MNIST(root=".",train=True,transform=tv.transforms.ToTensor(),download=True)
#testDataset = tv.datasets.MNIST(root=".",train=False,transform=tv.transforms.ToTensor(),download=True)
trainDataset = MyData(isTrain=True, nTrain=600)
testDataset = MyData(isTrain=False, nTest=100)
trainLoader = t.utils.data.DataLoader(dataset=trainDataset, batch_size=nTrainBatchSize, shuffle=True)
testLoader = t.utils.data.DataLoader(dataset=testDataset, batch_size=nTrainBatchSize, shuffle=True)
for epoch in range(40):
for i, (xTrain, yTrain) in enumerate(trainLoader):
xTrain = Variable(xTrain).cuda()
yTrain = Variable(yTrain).cuda()
opt.zero_grad()
y_, z = model(xTrain)
loss = ceLoss(y_, yTrain)
loss.backward()
opt.step()
if not (epoch + 1) % 10:
print("%s, epoch %d, loss = %f" % (dt.now(), epoch + 1, loss.data))
acc = 0
model.eval()
for xTest, yTest in testLoader:
xTest = Variable(xTest).cuda()
yTest = Variable(yTest).cuda()
y_, z = model(xTest)
def solve_lqr_subproblem(self, x_init, C, c, F, f, cost, dynamics, x, u, verbose,
no_op_forward=False):
if self.slew_rate_penalty is None or isinstance(cost, Module):
_lqr = LQRStep(
n_state=self.n_state,
n_ctrl=self.n_ctrl,
T=self.T,
verbose=verbose,
u_lower=self.u_lower,
u_upper=self.u_upper,
u_zero_I=self.u_zero_I,
true_cost=cost,
true_dynamics=dynamics,
delta_u=self.delta_u,
linesearch_decay=self.linesearch_decay,
max_linesearch_iter=self.max_linesearch_iter,
delta_space=True,
current_x=x,
current_u=u,
back_eps=self.back_eps,
no_op_forward=no_op_forward,
)
e = np.array([])
x, u = _lqr(x_init, C, c, F, f if f is not None else e)
return x, u, _lqr
else:
nsc = self.n_state + self.n_ctrl
_n_state = nsc
_nsc = _n_state + self.n_ctrl
n_batch = C.shape[1]
_C = np.zeros((self.T, n_batch, _nsc, _nsc), dtype='single')
half_gamI = np.expand_dims(np.expand_dims(self.slew_rate_penalty * np.eye(
self.n_ctrl), 0), 0).repeat(self.T, 0).repeat(n_batch, 1)
_C[:,:,:self.n_ctrl,:self.n_ctrl] = half_gamI
_C[:,:,-self.n_ctrl:,:self.n_ctrl] = -half_gamI
_C[:,:,:self.n_ctrl,-self.n_ctrl:] = -half_gamI
_C[:,:,-self.n_ctrl:,-self.n_ctrl:] = half_gamI
slew_C = _C.copy()
_C = _C + torch.nn.ZeroPad2d((self.n_ctrl, 0, self.n_ctrl, 0))(C)
_c = torch.cat((
torch.zeros(self.T, n_batch, self.n_ctrl).type_as(c),c), 2)
_F0 = torch.cat((
torch.zeros(self.n_ctrl, self.n_state+self.n_ctrl),
torch.eye(self.n_ctrl),
), 1).type_as(F).unsqueeze(0).unsqueeze(0).repeat(
self.T-1, n_batch, 1, 1
)
_F1 = torch.cat((
torch.zeros(
self.T-1, n_batch, self.n_state, self.n_ctrl
).type_as(F),F), 3)
_F = torch.cat((_F0, _F1), 2)
if f is not None:
_f = torch.cat((
torch.zeros(self.T-1, n_batch, self.n_ctrl).type_as(f),f), 2)
else:
_f = Variable(torch.Tensor())
u_data = util.detach_maybe(u)
if self.prev_ctrl is not None:
prev_u = self.prev_ctrl
if prev_u.ndimension() == 1:
prev_u = prev_u.unsqueeze(0)
if prev_u.ndimension() == 2:
prev_u = prev_u.unsqueeze(0)
prev_u = prev_u.data
else:
prev_u = torch.zeros(1, n_batch, self.n_ctrl).type_as(u)
utm1s = torch.cat((prev_u, u_data[:-1])).clone()
_x = torch.cat((utm1s, x), 2)
_x_init = torch.cat((Variable(prev_u[0]), x_init), 1)
if not isinstance(dynamics, LinDx):
_dynamics = CtrlPassthroughDynamics(dynamics)
else:
_dynamics = None
if isinstance(cost, QuadCost):
_true_cost = QuadCost(_C, _c)
else:
_true_cost = SlewRateCost(
cost, slew_C, self.n_state, self.n_ctrl
)
_lqr = LQRStep(
n_state=_n_state,
n_ctrl=self.n_ctrl,
T=self.T,
u_lower=self.u_lower,
u_upper=self.u_upper,
u_zero_I=self.u_zero_I,
true_cost=_true_cost,
true_dynamics=_dynamics,
delta_u=self.delta_u,
linesearch_decay=self.linesearch_decay,
max_linesearch_iter=self.max_linesearch_iter,
delta_space=True,
current_x=_x,
current_u=u,
back_eps=self.back_eps,
no_op_forward=no_op_forward,
)
x, u = _lqr(_x_init, _C, _c, _F, _f)
x = x[:,:,self.n_ctrl:]
return x, u, _lqr
for i in range(0, len(train[0])-batch_size,batch_size):
augment = True
video_list = [(train[0][k],augment)
for k in random_indices[i:(batch_size+i)]]
data = pool_threads.map(loadFrame,video_list)
next_batch = 0
for video in data:
if video.size==0: # there was an exception, skip this
next_batch = 1
if(next_batch==1):
continue
x = np.asarray(data,dtype=np.float32)
x = Variable(torch.FloatTensor(x)).cuda().contiguous()
y = train[1][random_indices[i:(batch_size+i)]]
y = torch.from_numpy(y).cuda()
output = model(x)
loss = criterion(output, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
prediction = output.data.max(1)[1]
accuracy = ( float( prediction.eq(y.data).sum() ) /float(batch_size))*100.0
if(epoch==0):
for i in range(future): # if we should predict the future
h_t, c_t = self.lstm1(output, (h_t, c_t))
h_t2, c_t2 = self.lstm2(h_t, (h_t2, c_t2))
output = self.linear(h_t2)
outputs += [output]
outputs = torch.stack(outputs, 1).squeeze(2)
return outputs
if __name__ == '__main__':
# set random seed to 0
np.random.seed(0)
torch.manual_seed(0)
# load data and make training set
data = torch.load('traindata.pt')
input = Variable(torch.from_numpy(data[3:, :-1]), requires_grad=False)
target = Variable(torch.from_numpy(data[3:, 1:]), requires_grad=False)
test_input = Variable(torch.from_numpy(data[:3, :-1]), requires_grad=False)
test_target = Variable(torch.from_numpy(data[:3, 1:]), requires_grad=False)
# build the model
seq = Sequence()
seq.double()
criterion = nn.MSELoss()
# use LBFGS as optimizer since we can load the whole data to train
optimizer = optim.LBFGS(seq.parameters(), lr=0.8)
#begin to train
for i in range(15):
print('STEP: ', i)
def closure():
optimizer.zero_grad()
# 一共有的batch数
num_batches = len(imlist) // batch_size + leftover
# im_batches构建
im_batches = [torch.cat((im_batches[i * batch_size: min((i + 1) * batch_size,
len(im_batches))])) for i in range(num_batches)]
#开始探测
write = 0
start_det_loop = time.time()
for i, batch in enumerate(im_batches):
# load the image
start = time.time()
if CUDA:
batch = batch.cuda()
prediction = model(Variable(batch, volatile=True), CUDA)
prediction = write_results(prediction, confidence, num_classes, nms_conf=nms_thesh)
end = time.time()
# 说明不存在探测对象，跳过 只返回了个 0
if type(prediction) == int:
for im_num, image in enumerate(imlist[i * batch_size: min((i + 1) * batch_size, len(imlist))]):
im_id = i * batch_size + im_num
print("{0:20s} predicted in {1:6.3f} seconds".format(image.split("/")[-1], (end - start) / batch_size))
print("{0:20s} {1:s}".format("Objects Detected:", ""))
print("----------------------------------------------------------")
continue
def initHidden(self, batch_size):
self.hidden = Variable(torch.zeros(batch_size, self.hidden_size))
if self._gpu == True:
self.hidden = self.hidden.cuda()
def train(self, dataset):
# Optimizers
self.optimizer_G = torch.optim.Adam(
itertools.chain(
self.encoder.parameters(),
self.decoder.parameters()
),
lr=self.config.train.lr,
betas=(self.config.train.b1, self.config.train.b2)
)
self.optimizer_D = torch.optim.Adam(
self.discriminator.parameters(),
lr=self.config.train.lr,
betas=(self.config.train.b1, self.config.train.b2))
# tensorboard callback
self.writer = SummaryWriter(os.path.join(self.output, 'log'))
self.running_loss_g = 0
self.running_loss_d = 0
dataloader = dataset.dataloader(tensor=self.Tensor)
for epoch in tqdm(range(self.config.train.n_epochs), total=self.config.train.n_epochs, desc='Epoch',
leave=True):
for batch in tqdm(dataloader, total=len(dataloader), desc='Bath'):
imgs = batch.reshape(-1, self.img_shape[-2], self.img_shape[-1])
# Adversarial ground truths
valid = Variable(self.Tensor(imgs.shape[0], 1).fill_(1.0), requires_grad=False)
fake = Variable(self.Tensor(imgs.shape[0], 1).fill_(0.0), requires_grad=False)
# Configure input
real_imgs = Variable(imgs.type(self.Tensor))
self.optimizer_G.zero_grad()
encoded_imgs = self.encoder(real_imgs)
decoded_imgs = self.decoder(encoded_imgs)
# Loss measures generator's ability to fool the discriminator
g_loss = \
0.001 * self.adversarial_loss(self.discriminator(encoded_imgs), valid) + \
0.999 * self.pixelwise_loss(decoded_imgs, real_imgs)
g_loss.backward()
self.optimizer_G.step()
self.running_loss_g += g_loss.item()
self.optimizer_D.zero_grad()
# Sample noise as discriminator ground truth
z = Variable(self.Tensor(np.random.normal(0, 1, (imgs.shape[0], self.config.struct.latent_dim))))
# Measure discriminator's ability to classify real from generated samples
real_loss = self.adversarial_loss(self.discriminator(z), valid)
fake_loss = self.adversarial_loss(self.discriminator(encoded_imgs.detach()), fake)
d_loss = 0.5 * (real_loss + fake_loss)
d_loss.backward()
self.optimizer_D.step()
self.running_loss_d += d_loss.item()
if epoch % 10 == 0:
save_path = '/root/weights'
torch.save(self.encoder.state_dict(), os.path.join(save_path, f'encoder_{self.name}_{epoch}'))
torch.save(self.decoder.state_dict(), os.path.join(save_path, f'decoder_{self.name}_{epoch}'))
torch.save(self.discriminator.state_dict(),
os.path.join(save_path, f'discriminator_{self.name}_{epoch}'))
self.tensorboard_callback(epoch, len(dataloader))
self.writer.close()
net = torch.nn.DataParallel(net,
device_ids=range(
torch.cuda.device_count()))
cudnn.benchmark = True
net.eval()
net.training = False
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for batch_idx, (inputs, targets) in enumerate(testloader):
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs), Variable(targets)
outputs = net(inputs)
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
acc = 100. * correct / total
print("| Test Result\tAcc@1: %.2f%%" % (acc))
sys.exit(0)
# Model
print('\n[Phase 2] : Model setup')
if args.resume:
# Load checkpoint
criterion = nn.MSELoss() # 定义损失函数为MSE（最小平方误差函数）
optimizer = optim.SGD(model.parameters(), lr=learning_rate) # 定义迭代优化算法为随机梯度下降算法
plt.ion() # 使图像变为交互模式
plt.figure() # 创建画布
loss_train = [] # 存储训练损失的数组
loss_test = []
if not LOAD_MODEL: # 训练
plt.scatter(avg_dBZ, real_RI, c='b', s=3) # 绘制散点图
eval_loss = 0
if cuda_available: # 将训练转移到GPU上进行
inputs = Variable(dBZ).cuda()
factors = Variable(factor).cuda()
values = Variable(RI).cuda()
else:
inputs = Variable(dBZ)
factors = Variable(factor)
values = Variable(RI)
inputs = inputs.view(inputs.size(0), 1, inputs.size(1), inputs.size(2))
if cuda_available:
tinputs = Variable(tdBZ).cuda()
tfactors = Variable(tfactor).cuda()
tvalues = Variable(tRI).cuda()
else:
tinputs = Variable(tdBZ)
tfactors = Variable(tfactor)
def train_vae(logger=None):
out_dir, listdir, featslistdir = get_dirpaths(args)
batchsize = args.batchsize
hiddensize = args.hiddensize
nmix = args.nmix
nepochs = args.epochs
data = colordata(\
os.path.join(out_dir, 'images'), \
listdir=listdir,\
featslistdir=featslistdir,
split='train')
nbatches = np.int_(np.floor(data.img_num/batchsize))
data_loader = DataLoader(dataset=data, num_workers=args.nthreads,\
batch_size=batchsize, shuffle=True, drop_last=True)
model = VAE()
model.cuda()
model.train(True)
optimizer = optim.Adam(model.parameters(), lr=5e-5)
itr_idx = 0
for epochs in range(nepochs):
train_loss = 0.
for batch_idx, (batch, batch_recon_const, batch_weights, batch_recon_const_outres, _) in \
tqdm(enumerate(data_loader), total=nbatches):
input_color = Variable(batch).cuda()
lossweights = Variable(batch_weights).cuda()
lossweights = lossweights.view(batchsize, -1)
input_greylevel = Variable(batch_recon_const).cuda()
z = Variable(torch.randn(batchsize, hiddensize))
optimizer.zero_grad()
mu, logvar, color_out = model(input_color, input_greylevel, z)
kl_loss, recon_loss, recon_loss_l2 = \
vae_loss(mu, logvar, color_out, input_color, lossweights, batchsize)
loss = kl_loss.mul(1e-2)+recon_loss
recon_loss_l2.detach()
loss.backward()
optimizer.step()
train_loss = train_loss + recon_loss_l2.data[0]
if(logger):
logger.update_plot(itr_idx, \
[kl_loss.data[0], recon_loss.data[0], recon_loss_l2.data[0]], \
plot_type='vae')
itr_idx += 1
if(batch_idx % args.logstep == 0):
data.saveoutput_gt(color_out.cpu().data.numpy(), \
batch.numpy(), \
'train_%05d_%05d' % (epochs, batch_idx), \
batchsize, \
net_recon_const=batch_recon_const_outres.numpy())
train_loss = (train_loss*1.)/(nbatches)
print('[DEBUG] VAE Train Loss, epoch %d has loss %f' % (epochs, train_loss))
test_loss = test_vae(model)
if(logger):
logger.update_test_plot(epochs, test_loss)
print('[DEBUG] VAE Test Loss, epoch %d has loss %f' % (epochs, test_loss))
torch.save(model.state_dict(), '%s/models/model_vae.pth' % (out_dir))
def mask2d(B, D, keep_prob, cuda=True):
m = torch.floor(torch.rand(B, D) + keep_prob) / keep_prob
m = Variable(m, requires_grad=False)
if cuda:
m = m.cuda()
return m
