# LD_LIBRARY_PATH /usr/local/cuda-8.0/lib64:$LD_LIBRARY_PATH
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
def eval_print(y_true, y_pred, y_logits):
print("accuracy %.6f" % metrics.accuracy_score(y_true, y_pred))
print("Precision %.6f" % metrics.precision_score(y_true, y_pred))
print("Recall %.6f" % metrics.recall_score(y_true, y_pred))
print("f1_score %.6f" % metrics.f1_score(y_true, y_pred))
fpr, tpr, threshold = metrics.roc_curve(y_true, y_logits)
print("auc_socre %.6f" % metrics.auc(fpr, tpr))
batch_size = 512
loader = DataLoader(train_mode=False)
model = AutoEncoder()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
# store
saver = tf.train.Saver()
saver.restore(sess, '../model/ae_model')
print('begin testing:')
losses = []
for iter, indices in enumerate(range(0, loader.test_size, batch_size)): #
idx_train, idx_valid = train_test_split(idx, test_size=0.1)
x_train, x_valid = x_train[idx_train], x_train[idx_valid]
y_train, y_valid = y_train[idx_train], y_train[idx_valid]
dataset_train = GetDataset(x=x_train,
y=y_train,
num_classes=max(y_test) + 1,
preproc_fn=preproc_fn,
augment_fn=TrainingAugmentation.augmentation)
dataset_valid = GetDataset(x=x_valid,
y=y_valid,
num_classes=max(y_test) + 1,
preproc_fn=preproc_fn,
augment_fn=TestingAugmentation.augmentation)
dataloader = DataLoader(dataset=dataset_train, batch_size=cfg.MODEL.BATCH_SIZE)
""" Pre-occupy the gpu, prevent after loading data but found gpu has already been taken"""
if cfg.MODEL.BACKBONE == "":
model = build_model(input_shape=(256, 256, 3),
output_num=2,
use_deformable=cfg.MODEL.USE_DEFORMABLE_CONV,
num_deform_group=cfg.MODEL.NUM_DEFORM_GROUP)
else:
model = build_resnet_model(input_shape=(256, 256, 3),
output_num=2,
use_deformable=cfg.MODEL.USE_DEFORMABLE_CONV,
num_deform_group=cfg.MODEL.NUM_DEFORM_GROUP,
backbone=cfg.MODEL.BACKBONE)
optim = tf.keras.optimizers.SGD(lr=cfg.MODEL.LEARNING_RATE,
nesterov=True,
net.load_state_dict(torch.load(args.load))
print('Model loaded from {}'.format(args.load))
if args.gpu:
net.cuda()
#net = torch.nn.DataParallel(net, device_ids=args.gpu).cuda()
# cudnn.benchmark = True # faster convolutions, but more memory
input_path = '../data/train_feature.npy'
target_path = '../data/train_social_label.npy'
train_set = get_train_data(input_path, target_path)
test_set = get_test_data(input_path, target_path)
train_data_loader = DataLoader(dataset=train_set,
num_workers=4,
batch_size=args.batchsize,
shuffle=True)
test_data_loader = DataLoader(dataset=test_set,
num_workers=4,
batch_size=args.batchsize,
shuffle=False)
# predit(net=net,
# train_loader = train_data_loader,
# val_loader = test_data_loader,
# epochs=args.epochs,
# batch_size=args.batchsize,
# lr=args.lr,
# gpu=args.gpu,
# img_scale=1,
# args =args)
def test_load_csv_data():
valid_csv_file_path = '../../examples/image_data/sample.csv'
invalid_csv_file_path = 'invalid_csv_file_path'
valid_image_dimensions = (48, 48)
channels = 1
invalid_image_dimensions = (50, 77)
csv_label_col = 0
csv_image_col = 1
valid_target_labels = [0, 1, 2, 3, 4, 5, 6]
invalid_target_labels = [8, 9, 10]
# should raise error when not given csv column indices for images and labels
with pytest.raises(ValueError):
DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=valid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col)
# should raise error when given invalid csv file path
with pytest.raises(FileNotFoundError):
DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=invalid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
# should raise error when given invalid csv column indices
with pytest.raises(ValueError):
DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=valid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=10)
# should raise error when given empty target_labels list
with pytest.raises(ValueError):
DataLoader(from_csv=True,
datapath=valid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
# should raise error when not given image dimensions
with pytest.raises(ValueError):
DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=valid_csv_file_path,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
# should raise error when given invalid image dimensions
with pytest.raises(ValueError):
DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=valid_csv_file_path,
image_dimensions=invalid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
# should raise error if no image samples found in csv file
with pytest.raises(AssertionError):
data_loader = DataLoader(from_csv=True,
target_labels=invalid_target_labels,
datapath=valid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
data_loader.get_data()
data_loader = DataLoader(from_csv=True,
target_labels=valid_target_labels,
datapath=valid_csv_file_path,
image_dimensions=valid_image_dimensions,
csv_label_col=csv_label_col,
csv_image_col=csv_image_col)
images, labels = data_loader.get_data()
# should return non-empty image and label arrays when given valid arguments
assert len(images) > 0 and len(labels) > 0
# should return same number of labels and images when given valid arguments
assert len(images) == len(labels)
# should reshape the images to given valid image_dimensions
assert list(images.shape[1:]) == list(valid_image_dimensions) + [channels]
def main(args):
if not torch.cuda.is_available():
logging.info('no gpu device available')
sys.exit(1)
np.random.seed(args.seed)
torch.cuda.set_device(args.gpu)
cudnn.benchmark = True
torch.manual_seed(args.seed)
cudnn.enabled = True
torch.cuda.manual_seed(args.seed)
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
criterion = nn.BCELoss()
criterion = criterion
model = Network(args.init_channels, CLASSES, args.layers, criterion)
model = model.cuda()
logging.info("param size = %fMB", utils.count_parameters_in_MB(model))
optimizer = torch.optim.SGD(model.parameters(),
args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
# * Data handling here
train_data = DataLoader(x_path="E:/URBAN_DATASET_BGH/train_x.npy",
y_path="E:/URBAN_DATASET_BGH/train_y.npy",
batch_size=args.batch_size,
shuffle=True)
train_queue = train_data.make_queue()
train_queue = train_queue[:int(len(train_queue) * args.train_portion)]
val_data = DataLoader(x_path="E:/URBAN_DATASET_BGH/val_x.npy",
y_path="E:/URBAN_DATASET_BGH/val_y.npy",
batch_size=args.batch_size,
shuffle=True)
valid_queue = val_data.make_queue()
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, float(args.epochs), eta_min=args.learning_rate_min)
architect = Architect(model, args)
mIoUs = [0]
for epoch in range(args.epochs):
scheduler.step()
lr = scheduler.get_lr()[0]
logging.info('epoch %d lr %e', epoch, lr)
genotype = model.genotype()
logging.info('genotype = %s', genotype)
# training
train_acc, train_iou = train(train_queue, valid_queue, model,
architect, criterion, optimizer, lr)
# here should be
logging.info('Final Train Acc %f', train_acc)
logging.info('Final Train mIoU %f', train_iou)
# validation
valid_acc, valid_iou = infer(valid_queue, model, criterion)
logging.info('Final Valid Acc %f', valid_acc)
logging.info('Final Valid mIoU %f', valid_iou)
# save the final genotype
if (max(mIoUs) < valid_iou):
print(
"Writing the computed genotype tp ./cnn/final_models/final_genotype.py"
)
utils.write_genotype(genotype)
mIoUs.append(valid_iou)
np.save(os.path.join(args.save, "mIoUs.npy"), mIoUs)
d_optimizer.load_state_dict(check_point['d_optimizer'])
generator.module.load_state_dict(check_point['generator'])
discriminator.module.load_state_dict(check_point['discriminator'])
else:
global_step = 0
loss_log = {'g_loss': [], 'd_loss': []}
global_step += 1
stage = 0
for i in range(len(iterations)):
if global_step > iterations[i]:
stage = i
else:
break
dataset = DataLoader(data_path,
batch_size[stage],
resize=resolution[stage] / 64,
preload=False)
generator.module.set_resolution(resolution[stage])
discriminator.module.set_resolution(resolution[stage])
print(
f'Starting at stage {stage}, batch_size:{batch_size[stage]}, resolution:{resolution[stage]}'
)
# Training
start = global_step
for global_step in trange(start, iterations[-1] + 1):
epoch_idx, batch_idx, real_image = dataset.get()
# fade in
fade_in_alpha = -1
if global_step < iterations[stage] + fade_in_itrs[stage]:
if opt.method == 'policy-MPUR':
policy_network_mpur = torch.load(model_path)['model']
policy_network_mpur.stats = stats
forward_model.policy_net = policy_network_mpur.policy_net
forward_model.policy_net.stats = stats
forward_model.policy_net.actor_critic = False
forward_model.intype('gpu')
forward_model.stats = stats
if 'ten' in opt.mfile:
forward_model.p_z = torch.load(
path.join(opt.model_dir, f'{opt.mfile}.pz'))
return forward_model, value_function, policy_network_il, policy_network_mper, stats
dataloader = DataLoader(None, opt, 'i80')
forward_model, value_function, policy_network_il, policy_network_mper, data_stats = load_models(
)
splits = torch.load(path.join(data_path, 'splits.pth'))
if opt.u_reg > 0.0:
forward_model.train()
forward_model.opt.u_hinge = opt.u_hinge
if hasattr(forward_model, 'value_function'):
forward_model.value_function.train()
planning.estimate_uncertainty_stats(forward_model,
dataloader,
n_batches=50,
npred=opt.npred)
gym.envs.registration.register(id='I-80-v1',
parser.add_argument('--num_classes',
type=int,
default=10,
help='number of classes')
parser.add_argument('--lr', type=float, default=1e-3, help='learning rate')
parser.add_argument('--epoches',
type=int,
default=20,
help='epochs of training')
parser.add_argument('--batchsize', type=int, default=64, help='batch size')
#parser.add_argument('--keep_prob',type = float,default = 0.5,help = 'keep probality for dropout')
opt = parser.parse_args()
print(opt)
criterion = nn.CrossEntropyLoss(size_average=False)
dataloader = DataLoader(opt.dataset, opt.batchsize)
trainloader, testloader = dataloader.load()
all_test_loss = {}
#all_train_loss = []
all_test_acc = {}
step_test_loss = {}
step_test_acc = {}
#all_train_acc = []
models = {
'L1':
VGG(vgg_name=opt.net,
Fc_BN=False,
Conv_BN=True,
drop_prob=0,
channels=opt.channels,
from utils import Log
if __name__ == '__main__':
device = torch.device("cuda:0")
loader = DataLoader(split='training',path_to_data=Config.data_path)
trainloader= data.DataLoader(loader, batch_size=Config.train_batch_size, num_workers=Config.train_num_workers, shuffle=True,drop_last=True)
loader = DataLoader(split='testing',path_to_data=Config.data_path)
testLoader= data.DataLoader(loader, batch_size=Config.test_batch_size, num_workers=Config.test_num_workers, shuffle=False,drop_last=False)
(batch,lbls)=next(iter(trainloader))
predicted_size=list(lbls.size())[1]
input_size=list(batch.size())[1]
# model = models.resnet18(pretrained=False)
# model.conv1 = nn.Conv2d(input_size, 64, kernel_size=7, stride=2, padding=3, bias=False)
# num_ftrs = model.fc.in_features
# model.fc = torch.nn.Linear(num_ftrs, predicted_size)
def train_net(net,
epochs=5,
data_dir='data/cells/',
n_classes=2,
lr=0.001,
val_percent=0.1,
save_cp=True,
gpu=False):
loader = DataLoader(data_dir)
N_train = loader.n_train()
optimizer = optim.SGD(net.parameters(),
lr=lr,
momentum=0.99,
weight_decay=0.005)
for epoch in range(epochs):
print('Epoch %d/%d' % (epoch + 1, epochs))
print('Training...')
net.train()
loader.setMode('train')
epoch_loss = 0
for i, (img, label) in enumerate(loader):
shape = img.shape
img = torch.from_numpy(img.reshape(1, 1, shape[0],
shape[1])).float()
if gpu:
img = img.cuda()
pred = net(img)
loss = getLoss(pred, label)
epoch_loss += loss.item()
print('Training sample %d / %d - Loss: %.6f' %
(i + 1, N_train, loss.item()))
# optimize weights
optimizer.zero_grad()
loss.backward()
optimizer.step()
torch.save(net.state_dict(),
join(data_dir, 'checkpoints') + '/CP%d.pth' % (epoch + 1))
print('Checkpoint %d saved !' % (epoch + 1))
print('Epoch %d finished! - Loss: %.6f' % (epoch + 1, epoch_loss / i))
# displays test images with original and predicted masks after training
loader.setMode('test')
net.eval()
with torch.no_grad():
for _, (img, label) in enumerate(loader):
shape = img.shape
img_torch = torch.from_numpy(img.reshape(1, 1, shape[0],
shape[1])).float()
if gpu:
img_torch = img_torch.cuda()
pred = net(img_torch)
pred_sm = softmax(pred)
_, pred_label = torch.max(pred_sm, 1)
plt.subplot(1, 3, 1)
plt.imshow(img * 255.)
plt.subplot(1, 3, 2)
plt.imshow(label * 255.)
plt.subplot(1, 3, 3)
plt.imshow(pred_label.cpu().detach().numpy().squeeze() * 255.)
plt.show()
def Using_DataLoader():
'''
##############################################
Step #2: Three variables are required to run DataLoader.
Variable #1, Data_File_Path: A path and data file must be specified.
Variable #2, dataType: CAEN digitizers will output data in one of three
formats: DAFCA_STD, DAFCA_DPP_MIXED, or DAFCA_DPP_LIST. This defines the
data structure for how data is pulled in. We will go through DAFCA_DPP_MIXED
thoroughly.
Variable #3, Num_Samples: This is the number of samples in a waveform, not
the number of waves
##############################################
'''
##############################################
Data_File_Path = "C:/Users/Giha/Documents/N3Glass/X1/1/dataFile0.dat"
dataType = DataLoader.DAFCA_DPP_MIXED
Num_Samples = 500
##############################################
Data = DataLoader(Data_File_Path, dataType, Num_Samples)
print("DataLoader has two useful functions to new users.")
print("\n")
print(
"The first useful function will tell you how many waves are in the specified file."
)
print("\n")
time.sleep(3)
Number_of_data_structures = Data.GetNumberOfWavesInFile()
print("In : " + str(Data_File_Path) + " , there are " +
str(Number_of_data_structures) +
" pulses, or more specifically, that many data structures.")
print("\n")
time.sleep(1)
print(
"The second useful function will load in a specified number of waves or data structures."
)
print("\n")
time.sleep(1)
var = input(
"Lets read in one wave and break down what we are reading in. Sound good? (Y/N): "
)
if var == "Y":
Waves = Data.LoadWaves(1)
print("\n")
time.sleep(1)
print("This one wave has the following structure:")
print("\n")
print('EventSize is the event size in number of bytes: ' +
str(Waves['EventSize'][0]))
print('Format is referring to the CAEN datatype: ' +
str(Waves['Format'][0]))
print('Channel is referring to the input channel on the digitizer: ' +
str(Waves['Channel'][0]))
print('Baseline is the baseline of the pulse: ' +
str(Waves['Baseline'][0]))
print('ShortGate is the tail integral of the pulse: ' +
str(Waves['ShortGate'][0]))
print('LongGate is the total integral of the pulse: ' +
str(Waves['LongGate'][0]))
print(
'TimeTag is a course absolute time for when a pulse begins (ns): '
+ str(Waves['TimeTag'][0]))
print(
'Extras can be thought of as a finer time that can be combined with TimeTag: '
+ str(Waves['Extras'][0]))
print('Samples are the actual wave samples: ' +
str(Waves['Samples'][0]))
print("\n")
time.sleep(1)
print(
"Baseline, ShortGate, and LongGate have generally not been used because they do not necessarily accuratley represent what they claim to."
)
print(
"For more infomration (especially when using Extras), please read the UM2580 DPP PSD User Manual found on CAEN's website."
)
print("\n")
time.sleep(1)
print(
"Now let's plot this pulse. When you are happy with looking at the pulse, close the figure."
)
x = np.arange(0, Num_Samples * 2, 2)
y = Waves['Samples'][0]
plt.plot(x, y)
plt.xlabel("Time (ns)")
plt.xlabel("Digitizer Units")
plt.show()
plt.close()
print("\n")
time.sleep(1)
print(
"From this pulse, we can attain useful information, but first we must subtract the baseline."
)
print("\n")
print(
"In DAFCA, the user can specify how much data of the pulse they want before the rising edge. This way a sufficient amount of data can be acquired to determine the baseline."
)
print(
"Generally, the baseline is determined by averaging the first 50 samples of the pulse."
)
time.sleep(1)
Baseline = np.average(Waves['Samples'][0][0:50])
print("\n")
print("In this case, the baseline of the pulse is: " + str(Baseline))
print("\n")
print("We can now subtract this baseline and plot the pulse.")
print("\n")
Baseline_Subtracted_Wave = Waves['Samples'][0] - Baseline
x = np.arange(0, Num_Samples * 2, 2)
y = Baseline_Subtracted_Wave
plt.plot(x, y)
plt.xlabel("Time (ns)")
plt.xlabel("Digitizer Units")
plt.show()
plt.close()
print("We can now attain some useful information about the pulse:")
print("\n")
Pulse_Height = np.max(Baseline_Subtracted_Wave)
Max_Index = np.argmax(Baseline_Subtracted_Wave)
negativeSamples = np.nonzero(
Baseline_Subtracted_Wave[Max_Index:] < 0)[0]
Pulse_Integral = np.sum(
Baseline_Subtracted_Wave[:Max_Index + negativeSamples[0]]) * 2
dynamic_range_volts = 0.5
number_of_bits = 15
VperLSB = dynamic_range_volts / (2**number_of_bits)
F = 0.2
Start_Time = CFD(Baseline_Subtracted_Wave, F)
print("Pulse Height (Digitizer Units): " + str(Pulse_Height))
print("Pulse Integral (Digitizer Units-ns): " + str(Pulse_Integral))
print("Start Time (ns): " + str(Start_Time))
print("\n")
print(
"To convert from Digitizer Units to Votlage, it is necessary to multiply by the dynamic range of the digitizer and divide by 2^(number of bits). In this case the conversion is 0.5/2^14. This yields:"
)
print("\n")
Pulse_Height = np.max(Baseline_Subtracted_Wave) * VperLSB
Pulse_Integral = np.sum(
Baseline_Subtracted_Wave[:Max_Index +
negativeSamples[0]]) * 2 * VperLSB
print("Pulse Height (mV): " + str(Pulse_Height))
print("Pulse Integral (mV-ns): " + str(Pulse_Integral))
print("\n")
print("The next code, GetWaveData, does these calculations for us.")
print("\n")
x = np.arange(0, Num_Samples * 2, 2)
y = Baseline_Subtracted_Wave
plt.plot(x, y)
plt.xlabel("Time (ns)")
plt.xlabel("Digitizer Units")
plt.show()
plt.close()
else:
print("Fine.")
def main():
opt = parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
random.seed(opt.seed)
numpy.random.seed(opt.seed)
torch.manual_seed(opt.seed)
data_path = 'traffic-data/state-action-cost/data_i80_v0'
dataloader = DataLoader(None, opt, 'i80')
(forward_model, value_function, policy_network_il, policy_network_mper,
data_stats) = load_models(opt, data_path, device)
splits = torch.load(path.join(data_path, 'splits.pth'))
if opt.u_reg > 0.0:
forward_model.train()
forward_model.opt.u_hinge = opt.u_hinge
if hasattr(forward_model, 'value_function'):
forward_model.value_function.train()
planning.estimate_uncertainty_stats(forward_model,
dataloader,
n_batches=50,
npred=opt.npred)
gym.envs.registration.register(
id='I-80-v1',
entry_point='map_i80_ctrl:ControlledI80',
kwargs=dict(
fps=10,
nb_states=opt.ncond,
display=False,
delta_t=0.1,
store_simulator_video=opt.save_sim_video,
show_frame_count=False,
))
print('Building the environment (loading data, if any)')
env_names = {
'i80': 'I-80-v1',
}
env = gym.make(env_names[opt.map])
plan_file = build_plan_file_name(opt)
print(f'[saving to {path.join(opt.save_dir, plan_file)}]')
# different performance metrics
time_travelled, distance_travelled, road_completed = [], [], []
# values saved for later inspection
action_sequences, state_sequences, cost_sequences = [], [], []
writer = utils.create_tensorboard_writer(opt)
n_test = len(splits['test_indx'])
set_start_method('spawn')
pool = Pool(opt.num_processes)
async_results = []
time_started = time.time()
total_images = 0
for j in range(n_test):
car_path = dataloader.ids[splits['test_indx'][j]]
timeslot, car_id = utils.parse_car_path(car_path)
car_sizes = torch.tensor(dataloader.car_sizes[sorted(
list(dataloader.car_sizes.keys()))[timeslot]][car_id])[None, :]
async_results.append(
pool.apply_async(
process_one_episode,
(opt, env, car_path, forward_model, policy_network_il,
data_stats, plan_file, j, car_sizes)))
for j in range(n_test):
simulation_result = async_results[j].get()
time_travelled.append(simulation_result.time_travelled)
distance_travelled.append(simulation_result.distance_travelled)
road_completed.append(simulation_result.road_completed)
action_sequences.append(
torch.from_numpy(simulation_result.action_sequence))
state_sequences.append(
torch.from_numpy(simulation_result.state_sequence))
cost_sequences.append(simulation_result.cost_sequence)
total_images += time_travelled[-1]
log_string = ' | '.join((
f'ep: {j + 1:3d}/{n_test}',
f'time: {time_travelled[-1]}',
f'distance: {distance_travelled[-1]:.0f}',
f'success: {road_completed[-1]:d}',
f'mean time: {torch.Tensor(time_travelled).mean():.0f}',
f'mean distance: {torch.Tensor(distance_travelled).mean():.0f}',
f'mean success: {torch.Tensor(road_completed).mean():.3f}',
))
print(log_string)
utils.log(path.join(opt.save_dir, f'{plan_file}.log'), log_string)
if writer is not None:
# writer.add_video(
# f'Video/success={simulation_result.road_completed:d}_{j}',
# simulation_result.images.unsqueeze(0),
# j
# )
writer.add_scalar('ByEpisode/Success',
simulation_result.road_completed, j)
writer.add_scalar('ByEpisode/Collision',
simulation_result.has_collided, j)
writer.add_scalar('ByEpisode/OffScreen',
simulation_result.off_screen, j)
writer.add_scalar('ByEpisode/Distance',
simulation_result.distance_travelled, j)
pool.close()
pool.join()
diff_time = time.time() - time_started
print('avg time travelled per second is', total_images / diff_time)
torch.save(action_sequences, path.join(opt.save_dir,
f'{plan_file}.actions'))
torch.save(state_sequences, path.join(opt.save_dir, f'{plan_file}.states'))
torch.save(cost_sequences, path.join(opt.save_dir, f'{plan_file}.costs'))
if writer is not None:
writer.close()
def evaluate(self, split):
sim = PanoSimulatorWithGraph(self.args, disable_rendering=True)
sim.record_traj(True)
self.mapper.eval()
self.model.eval()
self.policy.eval()
vln_eval = Evaluation(split)
with torch.no_grad():
if split == "val_seen":
self.dataloader = self.valseendata
elif split == "val_unseen":
self.dataloader = self.valunseendata
else:
self.dataloader = DataLoader(self.args, splits=[split])
iterations = int(
math.ceil(
len(self.dataloader.data) / float(self.args.batch_size)))
for it in tqdm(range(iterations),
desc="Evaluation Progress for %s split" % split):
# Load minibatch and simulator
seq, seq_mask, seq_lens, batch = self.dataloader.get_batch()
sim.newEpisode(batch)
# Initialize the mapper
xyzhe = sim.getXYZHE()
spatial_map, mask = self.mapper.init_map(xyzhe)
if self.args.viz_eval and it < self.args.viz_iterations:
floor_maps = self.floor_maps(sim.getState())
ended = torch.zeros(self.args.batch_size,
device=self.args.device).byte()
viz_counter = 0
for t in range(self.args.timesteps):
if self.args.policy_gt_belief:
path_xyzhe, path_len = self.dataloader.path_xyzhe()
else:
rgb, depth, states = sim.getPanos()
spatial_map, mask, ftm = self.mapper(
rgb, depth, states, spatial_map, mask)
del states
del ftm
features, _, _ = sim.getGraphNodes()
P = features.shape[0] # num graph nodes
belief_features = torch.empty(P,
self.args.max_steps,
device=self.args.device)
state = None
steps = self.args.max_steps - 1
belief = self.mapper.belief_map(
xyzhe, self.args.filter_input_sigma).log()
if t == 0:
belief_pred = torch.zeros(seq.shape[0],
self.args.max_steps,
self.args.heading_states,
belief.shape[-2],
belief.shape[-1],
device=spatial_map.device)
belief_pred[:, 0, :, :, :] = belief.exp()
sigma = self.args.filter_heatmap_sigma
gridcellsize = self.args.gridcellsize * self.args.belief_downsample_factor
belief_features[:, 0] = belief_at_nodes(
belief.exp(), features[:, :4], sigma, gridcellsize)
act_att_weights = torch.zeros(seq.shape[0], steps,
torch.max(seq_lens))
obs_att_weights = torch.zeros(seq.shape[0], steps,
torch.max(seq_lens))
for k in range(steps):
if self.args.policy_gt_belief:
target_heatmap = self.mapper.belief_map(
path_xyzhe[k + 1],
self.args.filter_heatmap_sigma)
belief_features[:, k + 1] = belief_at_nodes(
target_heatmap, features[:, :4], sigma,
gridcellsize)
belief_pred[:, k + 1, :, :, :] = target_heatmap
else:
input_belief = belief
# Train a filter
new_belief, obs_likelihood, state, act_att, obs_att, _ = self.model(
k, seq, seq_mask, seq_lens, input_belief,
spatial_map, state)
belief = new_belief + obs_likelihood
# Renormalize
belief = belief - belief.reshape(
belief.shape[0],
-1).logsumexp(dim=1).unsqueeze(1).unsqueeze(
1).unsqueeze(1)
belief_pred[:, k + 1, :, :, :] = belief.exp()
belief_features[:, k + 1] = belief_at_nodes(
belief.exp(), features[:, :4], sigma,
gridcellsize)
act_att_weights[:, k] = act_att
obs_att_weights[:, k] = obs_att
# Probs from policy
aug_features = torch.cat([features, belief_features],
dim=1)
log_prob = self.policy(aug_features)
# Take argmax action in the sim
_, action_idx = log_prob.exp().max(dim=1)
if self.args.viz_eval and it < self.args.viz_iterations:
num_cam_views = self.args.num_pano_views * self.args.num_pano_sweeps
rgb = rgb.permute(0, 2, 3,
1).reshape(num_cam_views,
self.args.batch_size,
rgb.shape[-2],
rgb.shape[-1], 3)
depth = depth.expand(-1, 3, -1, -1).permute(
0, 2, 3,
1).reshape(num_cam_views, self.args.batch_size,
depth.shape[-2], depth.shape[-1], 3)
# Save attention over instruction
if t == 0:
att_ims = []
belief_ims = [[]
for n in range(self.args.batch_size)]
for n in range(seq.shape[0]):
instruction = self.dataloader.tokenizer.decode_sentence(
seq[n]).split()
act_att = act_att_weights[n].cpu().numpy()
obs_att = obs_att_weights[n].cpu().numpy()
valid_act_att = act_att[:, :
seq_lens[n]].transpose(
)
valid_obs_att = obs_att[:, :
seq_lens[n]].transpose(
)
fig = viz_utils.plot_att_graph(
valid_act_att,
valid_obs_att,
instruction,
seq_lens[n].item(),
black_background=True)
if self.args.viz_gif:
att_ims.append(
viz_utils.figure_to_rgb(fig))
else:
fig.savefig(
"%s/attention-%s-it%d-n%d.png" %
(self.args.viz_folder, split, it, n),
facecolor=fig.get_facecolor(),
transparent=True)
plt.close('all')
for k in range(3):
if self.args.policy_gt_belief:
viz = floor_maps
else:
viz = self.overlay_mask(floor_maps, mask)
if k >= 1:
viz = self.overlay_belief(viz, belief_pred)
viz = self.overlay_goal(
viz,
self.dataloader.goal_coords() +
self.mapper.map_center[:, :2])
if k >= 2:
viz = self.overlay_local_graph(
viz, features, action_idx)
else:
viz = self.overlay_local_graph(viz, features)
for n in range(len(viz)):
if not ended[n]:
if self.args.viz_gif:
image = viz[n] * 255
# Add attention image on left
min_val = image.shape[
0] // 2 - att_ims[n].shape[0] // 2
max_val = min_val + att_ims[n].shape[0]
image = np.flip(
image[min_val:max_val,
min_val:max_val, :], 2)
image = np.concatenate(
[att_ims[n], image], axis=1)
# Add rgb images at bottom
new_width = int(image.shape[-2] /
float(rgb.shape[0]))
new_height = int(new_width *
rgb.shape[-3] /
float(rgb.shape[-2]))
rgb_ims = [
cv2.resize(
rgb[i,
n].cpu().detach().numpy(),
(new_width, new_height))
for i in range(rgb.shape[0])
]
rgb_ims = np.concatenate(rgb_ims,
axis=1)
# Add depth images at bottom
depth_ims = [
cv2.resize(
depth[i, n].cpu().detach(
).numpy() / 200.0,
(new_width, new_height))
for i in range(depth.shape[0])
]
depth_ims = np.concatenate(depth_ims,
axis=1)
image = np.concatenate(
[image, rgb_ims, depth_ims],
axis=0)
belief_ims[n].append(
image.astype(np.uint8))
else:
filename = '%s/belief-%s-it%d-n%d-t%d_%d.png' % (
self.args.viz_folder, split, it, n,
t, viz_counter)
cv2.imwrite(filename, viz[n] * 255)
viz_counter += 1
ended |= sim.takeMultiStepAction(action_idx)
if ended.all():
break
if self.args.viz_gif and self.args.viz_eval and it < self.args.viz_iterations:
import imageio
for n in range(self.args.batch_size):
filename = '%s/%s-%s-it%d-n%d' % (
self.args.viz_folder, split, batch[n]['instr_id'],
it, n)
if not os.path.exists(filename):
os.makedirs(filename)
with imageio.get_writer(filename + '.gif',
mode='I',
format='GIF-PIL',
subrectangles=True,
fps=1) as writer:
for i, image in enumerate(belief_ims[n]):
writer.append_data(image)
cv2.imwrite("%s/%04d.png" % (filename, i),
np.flip(image, 2))
# Eval
out_dir = "%s/%s" % (args.result_dir, args.exp_name)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
output_file = "%s/%s_%s_%d.json" % (out_dir, split, args.exp_name,
args.val_epoch)
with open(output_file, 'w') as f:
json.dump(sim.traj, f)
scores = vln_eval.score(output_file)
print(scores)
with open(output_file.replace('.json', '_scores.json'), 'w') as f:
json.dump(scores, f)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-task', type=str, default='ranking')
parser.add_argument('-model', type=str, default='bert')
parser.add_argument('-max_input', type=int, default=1280000)
parser.add_argument('-test', type=str, default='./data/test_toy.jsonl')
parser.add_argument('-vocab', type=str, default='allenai/scibert_scivocab_uncased')
parser.add_argument('-ent_vocab', type=str, default='')
parser.add_argument('-pretrain', type=str, default='allenai/scibert_scivocab_uncased')
parser.add_argument('-checkpoint', type=str, default='./checkpoints/bert.bin')
parser.add_argument('-res', type=str, default='./results/bert.trec')
parser.add_argument('-mode', type=str, default='cls')
parser.add_argument('-n_kernels', type=int, default=21)
parser.add_argument('-max_query_len', type=int, default=32)
parser.add_argument('-max_doc_len', type=int, default=256)
parser.add_argument('-maxp', action='store_true', default=False)
parser.add_argument('-batch_size', type=int, default=32)
args = parser.parse_args()
args.model = args.model.lower()
if args.model == 'bert':
tokenizer = AutoTokenizer.from_pretrained(args.vocab)
print('reading test data...')
if args.maxp:
test_set = BertMaxPDataset(
dataset=args.test,
tokenizer=tokenizer,
mode='test',
query_max_len=args.max_query_len,
doc_max_len=args.max_doc_len,
max_input=args.max_input,
task=args.task
)
elif args.model == 'longformer':
tokenizer = AutoTokenizer.from_pretrained(args.vocab)
print('reading test data...')
if args.maxp:
test_set = longformerMaxpDataset(
dataset=args.test,
tokenizer=tokenizer,
mode='test',
query_max_len=args.max_query_len,
doc_max_len=args.max_doc_len,
max_input=args.max_input,
task=args.task
)
'''
else:
test_set = om.data.datasets.BertDataset(
dataset=args.test,
tokenizer=tokenizer,
mode='test',
query_max_len=args.max_query_len,
doc_max_len=args.max_doc_len,
max_input=args.max_input,
task=args.task
)
'''
'''
elif args.model == 'roberta':
tokenizer = AutoTokenizer.from_pretrained(args.vocab)
print('reading test data...')
test_set = om.data.datasets.RobertaDataset(
dataset=args.test,
tokenizer=tokenizer,
mode='test',
query_max_len=args.max_query_len,
doc_max_len=args.max_doc_len,
max_input=args.max_input,
task=args.task
)
'''
'''
else:
tokenizer = om.data.tokenizers.WordTokenizer(
pretrained=args.vocab
)
print('reading test data...')
test_set = om.data.datasets.Dataset(
dataset=args.test,
tokenizer=tokenizer,
mode='test',
query_max_len=args.max_query_len,
doc_max_len=args.max_doc_len,
max_input=args.max_input,
task=args.task
)
'''
test_loader = DataLoader(
dataset=test_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=0
)
if args.model == 'bert' or args.model == 'roberta':
if args.maxp:
model = BertMaxP(
pretrained=args.pretrain,
max_query_len=args.max_query_len,
max_doc_len=args.max_doc_len,
mode=args.mode,
task=args.task
)
'''
else:
model = om.models.Bert(
pretrained=args.pretrain,
mode=args.mode,
task=args.task
)
'''
elif args.model == "longformer":
if args.maxp:
model = LongformerMaxp(
pretrained=args.pretrain,
max_query_len=args.max_query_len,
max_doc_len=args.max_doc_len,
mode=args.mode,
task=args.task
)
else:
raise ValueError('model name error.')
state_dict = torch.load(args.checkpoint)
if args.model == 'bert':
st = {}
for k in state_dict:
print(k)
if k.startswith('bert'):
st['_model'+k[len('bert'):]] = state_dict[k]
elif k.startswith('classifier'):
st['_dense'+k[len('classifier'):]] = state_dict[k]
else:
st[k] = state_dict[k]
model.load_state_dict(st)
elif args.model == 'longformer':
st = {}
for k in state_dict:
print(k)
'''
if k.startswith('bert'):
st['_model'+k[len('bert'):]] = state_dict[k]
elif k.startswith('classifier'):
st['_dense'+k[len('classifier'):]] = state_dict[k]
else:
st[k] = state_dict[k]
'''
model.load_state_dict(state_dict)
else:
model.load_state_dict(state_dict)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
rst_dict = test(args, model, test_loader, device)
with open("test_result.tmp", 'w') as writer:
F1score=0
TP=0
FP=0
FN=0
for q_id, scores in rst_dict.items():
res = sorted(scores.items(), key=lambda x: x[1], reverse=True)
for rank, value in enumerate(res):
writer.write(q_id+' '+str(value[0])+' '+str(rank+1)+' '+ str(value[1])+' bertmaxp\n')
type=int,
default=100,
help="number of epochs")
parser.add_argument("--batch_size",
type=int,
default=3,
help="size of each image batch")
parser.add_argument("--train_path",
type=str,
default="config/train.txt",
help="txt path saving image paths")
parser.add_argument("--img_size",
type=int,
default=416,
help="size of each image dimension")
opt = parser.parse_args()
print(opt)
dataset = DataLoader(opt.train_path)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=0,
pin_memory=False)
for batch_i, (img_path, images, labels) in enumerate(dataloader):
print("batch_i: ", batch_i)
print("images: ", images)
print("labels: ", labels)
print("=" * 50)
# instance segmentation:
lambda data_dict: {
**data_dict,
**dict(
zip(["segm", "bboxes", "probs"],
seg_engine(data_dict["input"], scaled_boxes)))
},
]
########################################
## build async processor
########################################
loader = DataLoader(
data_stream,
batch_size=1,
num_workers=1,
pin_memory=True,
processors=processors,
)
@torch.no_grad()
def main_loop():
for data_dict in tqdm.tqdm(loader):
segm = data_dict["segm"].cpu().numpy()[0].transpose(1, 2,
0) # [512, 512, 4]
input = (segm[:, :, 0:3] * 0.5) + 0.5
output = (segm[:, :, 0:3] * segm[:, :, 3:4] * 0.5) + 0.5
x1, y1, x2, y2 = scaled_boxes[0].cpu().numpy()[0]
window = np.hstack([input, output]).astype(np.float32)
def train(args, net):
# Begin tf session
with tf.Session() as sess:
# Initialize variables
tf.global_variables_initializer().run()
saver = tf.train.Saver(tf.global_variables(), max_to_keep=5)
# load from previous save
if len(args.ckpt_name) > 0:
saver.restore(sess, os.path.join(args.save_dir, args.ckpt_name))
# Load data
shift = sess.run(net.shift)
scale = sess.run(net.scale)
data_loader = DataLoader(args, shift, scale)
sess.run(tf.assign(net.shift, data_loader.shift_x))
sess.run(tf.assign(net.scale, data_loader.scale_x))
#Function to evaluate loss on validation set
def val_loss():
data_loader.reset_batchptr_val()
loss = 0.0
for b in xrange(data_loader.n_batches_val):
# Get inputs
batch_dict = data_loader.next_batch_val()
x = batch_dict["inputs"]
# Construct inputs for network
feed_in = {}
feed_in[net.x] = np.reshape(x, (args.batch_size*(args.seq_length+1), 128, 256, 4))
if args.kl_weight > 0.0:
feed_in[net.kl_weight] = args.kl_weight
else:
feed_in[net.kl_weight] = 1.0
# Find loss
feed_out = net.cost
cost = sess.run(feed_out, feed_in)
loss += cost
return loss/data_loader.n_batches_val
# Initialize variable to track validation score over time
old_score = 1e9
count_decay = 0
decay_epochs = []
# Set initial learning rate and weight on kl divergence
print 'setting learning rate to ', args.learning_rate
sess.run(tf.assign(net.learning_rate, args.learning_rate))
# Define temperature for annealing kl_weight
T = 5*data_loader.n_batches_train
count = 0
# Loop over epochs
for e in xrange(args.num_epochs):
# Initialize loss
loss = 0.0
rec_loss = 0.0
kl_loss = 0.0
# Evaluate loss on validation set
score = val_loss()
print('Validation Loss: {0:f}'.format(score))
# Set learning rate
if (old_score - score) < 0.01:
count_decay += 1
decay_epochs.append(e)
if len(decay_epochs) >= 3 and np.sum(np.diff(decay_epochs)[-2:]) == 2: break
print 'setting learning rate to ', args.learning_rate * (args.decay_rate ** count_decay)
sess.run(tf.assign(net.learning_rate, args.learning_rate * (args.decay_rate ** count_decay)))
old_score = score
data_loader.reset_batchptr_train()
print 'learning rate is set to ', args.learning_rate * (args.decay_rate ** count_decay)
# Loop over batches
for b in xrange(data_loader.n_batches_train):
start = time.time()
count += 1
# Update kl_weight
if args.kl_weight > 0.0:
kl_weight = args.kl_weight
else:
kl_weight = min(0.1, 0.01 + count/float(T))
# Get inputs
batch_dict = data_loader.next_batch_train()
x = batch_dict["inputs"]
# Construct inputs for network
feed_in = {}
feed_in[net.x] = np.reshape(x, (args.batch_size*(args.seq_length+1), 128, 256, 4))
feed_in[net.kl_weight] = kl_weight
# Find loss and perform training operation
feed_out = [net.cost, net.loss_reconstruction, net.kl_loss, net.train]
out = sess.run(feed_out, feed_in)
# Update and display cumulative losses
loss += out[0]
rec_loss += out[1]
kl_loss += out[2]
end = time.time()
# Print loss
if (e * data_loader.n_batches_train + b) % 10 == 0 and b > 0:
print "{}/{} (epoch {}), train_loss = {:.3f}, time/batch = {:.3f}" \
.format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train,
e, loss/10., end - start)
print "{}/{} (epoch {}), rec_loss = {:.3f}, time/batch = {:.3f}" \
.format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train,
e, rec_loss/10., end - start)
print "{}/{} (epoch {}), kl_loss = {:.3f}, time/batch = {:.3f}" \
.format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train,
e, kl_loss/10., end - start)
print ''
loss = 0.0
rec_loss = 0.0
kl_loss = 0.0
# Save model every epoch
checkpoint_path = os.path.join(args.save_dir, args.save_name + '.ckpt')
saver.save(sess, checkpoint_path, global_step = e)
print "model saved to {}".format(checkpoint_path)
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import time from tqdm import tqdm IF_SAVE = 0 SAVE_NAME = 'five_fc' ITERATION = 400 random.seed(0) np.random.seed(0) torch.manual_seed(0) CLASS = 10 dl = DataLoader(True,cuda = 1) images,labels = dl.get_all() #images, labels = images[:18000],labels[:18000] dl_test = DataLoader(False,cuda = 1) images_t,labels_t = dl_test.get_all() accumulate = torch.ones((labels.shape[0],CLASS),dtype = torch.float32).cuda() accumulate_t = torch.ones((labels_t.shape[0],CLASS),dtype = torch.float32).cuda() saved_data = np.zeros((ITERATION,5,2),dtype = int) saved_mask = np.zeros((ITERATION,CLASS),dtype = int) FC_TRAINING_ITERATION = 5000 FC_START_TIME = 1
def train_pixpro(args, logger, initial_epoch, strategy, num_workers):
##########################
# Dataset
##########################
trainset = set_dataset(args.task, args.data_path)
steps_per_epoch = args.steps or len(trainset) // args.batch_size
logger.info("TOTAL STEPS OF DATASET FOR TRAINING")
logger.info("========== TRAINSET ==========")
logger.info(f" --> {len(trainset)}")
logger.info(f" --> {steps_per_epoch}")
##########################
# Model & Generator
##########################
train_generator = DataLoader(args, 'train', trainset,
args.batch_size).dataloader
with strategy.scope():
model = PixPro(logger,
norm='bn' if num_workers == 1 else 'syncbn',
channel=256,
gamma=args.gamma,
num_layers=args.num_layers,
snapshot=args.snapshot)
if args.summary:
model.summary()
return
lr_scheduler = OptionalLearningRateSchedule(
lr=args.lr,
lr_mode=args.lr_mode,
lr_interval=args.lr_interval,
lr_value=args.lr_value,
total_epochs=args.epochs,
steps_per_epoch=steps_per_epoch,
initial_epoch=initial_epoch)
model.compile(
# TODO : apply LARS
optimizer=tf.keras.optimizers.SGD(lr_scheduler, momentum=.9),
batch_size=args.batch_size,
num_workers=num_workers,
run_eagerly=None)
##########################
# Train
##########################
callbacks, initial_epoch = create_callbacks(args, logger, initial_epoch)
if callbacks == -1:
logger.info('Check your model.')
return
elif callbacks == -2:
return
model.fit(
train_generator,
epochs=args.epochs,
callbacks=callbacks,
initial_epoch=initial_epoch,
steps_per_epoch=steps_per_epoch,
)
pprint(config)
# create save_dir folder if not exists
if not os.path.exists(config['save_dir']):
os.makedirs(config['save_dir'])
# Load tokenizer
tokenizer = WPTokenizer(os.path.join(config['pretrained_model_dir'],
'vocab.txt'),
lowercase=True)
tokenizer.enable_truncation(max_length=config['max_len'])
print("load data...")
dataloader = DataLoader(tokenizer,
config['max_len'],
use_vae=True,
batch_size=config["batch_size"],
ae_epochs=config['ae_epochs'])
dataloader.set_train(config['train_path'])
dataloader.set_dev(config['dev_path'])
dataloader.save_autoencoder(
os.path.join(config['save_dir'], 'autoencoder.weights'))
dataloader.save_vocab(os.path.join(config['save_dir'], 'vocab.pickle'))
accuracy_list = []
f1_list = []
for idx in range(1, config['iterations'] + 1):
print("build generator")
generator = DataGenerator(config['batch_size'], config['max_len'])
generator.set_dataset(dataloader.train_set)
metrics_callback = Metrics(
def test_load_time_series_directory_data():
invalid_directory_path = 'invalid_directory_path'
valid_dummy_directory = '../resources/dummy_time_series_data_directory'
empty_dummy_directory = '../resources/dummy_empty_data_directory'
valid_time_steps = 4
channels = 1
# should raise error when receives an invalid directory path
with pytest.raises(NotADirectoryError):
DataLoader(from_csv=False,
datapath=invalid_directory_path,
time_steps=4)
# should raise error when tries to load empty directory
data_loader = DataLoader(from_csv=False,
datapath=empty_dummy_directory,
time_steps=4)
with pytest.raises(AssertionError):
data_loader.get_data()
# should raise error when given time_step argument that is less than 1
with pytest.raises(ValueError):
DataLoader(from_csv=False,
datapath=valid_dummy_directory,
time_steps=-4)
# should raise error when given time_step argument that not an integer
with pytest.raises(ValueError):
DataLoader(from_csv=False,
datapath=valid_dummy_directory,
time_steps=4.7)
# should raise error when tries to load time series sample
# containing a quantity of images less than the time_steps argument
with pytest.raises(ValueError):
data_loader = DataLoader(from_csv=False,
datapath=valid_dummy_directory,
time_steps=10)
data_loader.get_data()
# should assign an image's parent directory name as its label
data_loader = DataLoader(from_csv=False,
datapath=valid_dummy_directory,
time_steps=valid_time_steps)
samples, labels, label_index_map = data_loader.get_data()
label_count = len(label_index_map.keys())
label = [0] * label_count
label[label_index_map['happiness']] = 1
assert label == labels[0]
data_loader = DataLoader(from_csv=False,
datapath=valid_dummy_directory,
time_steps=valid_time_steps)
samples, labels, label_index_map = data_loader.get_data()
# should return non-empty image and label arrays when given valid arguments
assert len(samples) > 0 and len(labels) > 0
# should return same number of labels and images when given valid arguments
assert len(samples) == len(labels)
# should reshape image to contain channel_axis in channel_last format
assert samples.shape[1] == valid_time_steps
# should reshape image to contain channel_axis in channel_last format
assert samples.shape[-1] == channels
from vocab import VocabBuilder
from dataloader import DataLoader
from model import RNN
filepath = "./dataset/dataset.csv"
vocab_obj = VocabBuilder(filepath=filepath)
word_to_index = vocab_obj.word_to_index
label_to_index = vocab_obj.label_to_index
index_to_label = {}
for label, index in label_to_index.items():
index_to_label[index] = label
loader = DataLoader(filepath=filepath,
word_to_index=word_to_index,
label_to_index=label_to_index,
batch_size=128)
vocab_size = len(word_to_index)
embedding_size = 128
num_output = len(label_to_index)
model = RNN(vocab_size=vocab_size,
embed_size=embedding_size,
num_output=num_output,
rnn_model="LSTM",
use_last=True,
hidden_size=128,
embedding_tensor=None,
num_layers=2,
batch_first=True)
# stats = torch.load('/misc/vlgscratch4/LecunGroup/nvidia-collab/traffic-data-atcold/data_i80_v0/data_stats.pth')
# model.stats=stats
if 'ten' in opt.mfile:
pzfile = opt.model_dir + opt.mfile + '.pz'
p_z = torch.load(pzfile)
model.p_z = p_z
if opt.actions_subsample == -1:
opt.context_dim = 0
model.intype('gpu')
model.cuda()
model.disable_unet = False
print('[loading data]')
dataloader = DataLoader(None, opt, opt.dataset)
# training and testing functions. We will compute several losses:
# loss_i: images
# loss_s: states
# loss_c: costs
# loss_p: prior (optional)
def compute_loss(targets, predictions, gamma=1.0, r=True):
target_images, target_states, target_costs = targets
pred_images, pred_states, pred_costs, loss_p = predictions
loss_i = F.mse_loss(pred_images, target_images,
reduce=False).mean(4).mean(3).mean(2)
loss_s = F.mse_loss(pred_states, target_states, reduce=False).mean(2)
# loss_c = F.mse_loss(pred_costs, target_costs, reduce=False).mean(2)
self.fc3 = nn.Linear(32, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
# print(x.shape)
out = self.backbone(x)
# print('backbone', out.shape)
out = out.view(out.size(0), -1)
# print('view', out.shape)
out = self.fc1(out)
# print('fc1',out.shape)
out = self.dropout1(out)
out = self.fc2(out)
out = self.dropout2(out)
out = self.fc3(out)
# print('fc2',out.shape)
out = self.sigmoid(out)
return out
if __name__ == '__main__':
loader = DataLoader('data/', 'train')
train_data_loader = torch.utils.data.DataLoader(loader,
batch_size=1,
shuffle=False,
num_workers=0)
idx, (image, label) = next(enumerate(train_data_loader))
net = ResNet()
net.forward(image)
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets
from mpldatacursor import datacursor
from dataloader import DataLoader
from transformer import Transformer
dataLoader = DataLoader()
path = 'D:/Documents/учёба/КНТ/4 курс 2 семестр/dataset недвижимость СПБ/обработанные данные/РАЙОНЫ2.csv'
fit_path = None
# загружаем датасет
(X_train,
Y_train), (X_test,
Y_test) = dataLoader.load(path=path,
labels=['Широта', 'Долгота', 'Район'],
test_size=0.2,
fit_path=fit_path)
# нормализуем координаты тем же методом, что и для нейронной сети
x_transformer = Transformer(transformer='QuantileTransformer')
x_transformer.fit(X_train)
X_train_norm = x_transformer.transform(X_train)
# нормализуем классы в вектора [ 2. 16. 7. ... 9. 16. 7.]
y_transformer = Transformer(transformer='OrdinalEncoder')
y_transformer.fit(Y_train)
y_train_norm = y_transformer.transform(Y_train).reshape(-1)
labels = y_transformer.transformer.categories_[0]
model.load_json(args.load_model, clone_tensors=True)
model.replace_tokendata(args.input_json)
print(model.layers)
logger.info('%s model with %d parameters' %
('Created' if args.load_model is None else 'Loaded',
sum((p.numel() for p in model.parameters()))))
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
scheduler = optim.lr_scheduler.StepLR(optimizer, args.lrdecay_every,
args.lrdecay_factor)
crit = nn.CrossEntropyLoss(reduction='none' if args.use_masks else 'mean')
logger.info('Loading data')
loader = DataLoader(filename=args.input_h5,
batch_size=args.batch_size,
seq_length=args.seq_length)
device = torch.device(args.device)
if args.layerdevices:
for ld in args.layerdevices:
start, end, device = ld.split(',')
for layerid in range(int(start), int(end) + 1):
print("Moving layer %d-%s to device %s" %
(layerid, model.layers[layerid], device))
model.layers[layerid].to(device)
else:
model.to(device)
double_seq_on = [int(x) for x in args.double_seq_on.split(',')
] if args.double_seq_on else []
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--device', type=str, default='cuda:0',
help='gpu device number of using')
parser.add_argument('--config', type=str, default=os.path.join('.', 'config', '5way_1shot_resnet12_mini-imagenet.py'),
help='config file with parameters of the experiment. '
'It is assumed that the config file is placed under the directory ./config')
parser.add_argument('--checkpoint_dir', type=str, default=os.path.join('.', 'checkpoints'),
help='path that checkpoint will be saved and loaded. '
'It is assumed that the checkpoint file is placed under the directory ./checkpoints')
parser.add_argument('--num_gpu', type=int, default=1,
help='number of gpu')
parser.add_argument('--display_step', type=int, default=100,
help='display training information in how many step')
parser.add_argument('--log_step', type=int, default=100,
help='log information in how many steps')
parser.add_argument('--log_dir', type=str, default=os.path.join('.', 'logs'),
help='path that log will be saved. '
'It is assumed that the checkpoint file is placed under the directory ./logs')
parser.add_argument('--dataset_root', type=str, default='./data',
help='root directory of dataset')
parser.add_argument('--seed', type=int, default=222,
help='random seed')
parser.add_argument('--mode', type=str, default='train',
help='train or eval')
args_opt = parser.parse_args()
config_file = args_opt.config
# Set train and test datasets and the corresponding data loaders
config = imp.load_source("", config_file).config
train_opt = config['train_config']
eval_opt = config['eval_config']
args_opt.exp_name = '{}way_{}shot_{}_{}'.format(train_opt['num_ways'],
train_opt['num_shots'],
config['backbone'],
config['dataset_name'])
train_opt['num_queries'] = 1
eval_opt['num_queries'] = 1
set_logging_config(os.path.join(args_opt.log_dir, args_opt.exp_name))
logger = logging.getLogger('main')
# Load the configuration params of the experiment
logger.info('Launching experiment from: {}'.format(config_file))
logger.info('Generated logs will be saved to: {}'.format(args_opt.log_dir))
logger.info('Generated checkpoints will be saved to: {}'.format(args_opt.checkpoint_dir))
print()
logger.info('-------------command line arguments-------------')
logger.info(args_opt)
print()
logger.info('-------------configs-------------')
logger.info(config)
# set random seed
np.random.seed(args_opt.seed)
torch.manual_seed(args_opt.seed)
torch.cuda.manual_seed_all(args_opt.seed)
random.seed(args_opt.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
if config['dataset_name'] == 'mini-imagenet':
dataset = MiniImagenet
print('Dataset: MiniImagenet')
elif config['dataset_name'] == 'tiered-imagenet':
dataset = TieredImagenet
print('Dataset: TieredImagenet')
elif config['dataset_name'] == 'cifar-fs':
dataset = Cifar
print('Dataset: Cifar')
elif config['dataset_name'] == 'cub-200-2011':
dataset = CUB200
print('Dataset: CUB200')
else:
logger.info('Invalid dataset: {}, please specify a dataset from '
'mini-imagenet, tiered-imagenet, cifar-fs and cub-200-2011.'.format(config['dataset_name']))
exit()
cifar_flag = True if args_opt.exp_name.__contains__('cifar') else False
if config['backbone'] == 'resnet12':
enc_module = ResNet12(emb_size=config['emb_size'], cifar_flag=cifar_flag)
print('Backbone: ResNet12')
elif config['backbone'] == 'convnet':
enc_module = ConvNet(emb_size=config['emb_size'], cifar_flag=cifar_flag)
print('Backbone: ConvNet')
else:
logger.info('Invalid backbone: {}, please specify a backbone model from '
'convnet or resnet12.'.format(config['backbone']))
exit()
gnn_module = DPGN(config['num_generation'],
train_opt['dropout'],
train_opt['num_ways'] * train_opt['num_shots'],
train_opt['num_ways'] * train_opt['num_shots'] + train_opt['num_ways'] * train_opt['num_queries'],
train_opt['loss_indicator'],
config['point_distance_metric'],
config['distribution_distance_metric'])
# multi-gpu configuration
[print('GPU: {} Spec: {}'.format(i, torch.cuda.get_device_name(i))) for i in range(args_opt.num_gpu)]
if args_opt.num_gpu > 1:
print('Construct multi-gpu model ...')
enc_module = nn.DataParallel(enc_module, device_ids=range(args_opt.num_gpu), dim=0)
gnn_module = nn.DataParallel(gnn_module, device_ids=range(args_opt.num_gpu), dim=0)
print('done!\n')
if not os.path.exists(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name)):
os.makedirs(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name))
logger.info('no checkpoint for model: {}, make a new one at {}'.format(
args_opt.exp_name,
os.path.join(args_opt.checkpoint_dir, args_opt.exp_name)))
best_step = 0
else:
if not os.path.exists(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name, 'model_best.pth.tar')):
best_step = 0
else:
logger.info('find a checkpoint, loading checkpoint from {}'.format(
os.path.join(args_opt.checkpoint_dir, args_opt.exp_name)))
best_checkpoint = torch.load(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name, 'model_best.pth.tar'))
logger.info('best model pack loaded')
best_step = best_checkpoint['iteration']
enc_module.load_state_dict(best_checkpoint['enc_module_state_dict'])
gnn_module.load_state_dict(best_checkpoint['gnn_module_state_dict'])
logger.info('current best test accuracy is: {}, at step: {}'.format(best_checkpoint['test_acc'], best_step))
dataset_train = dataset(root=args_opt.dataset_root, partition='train')
dataset_valid = dataset(root=args_opt.dataset_root, partition='val')
dataset_test = dataset(root=args_opt.dataset_root, partition='test')
train_loader = DataLoader(dataset_train,
num_tasks=train_opt['batch_size'],
num_ways=train_opt['num_ways'],
num_shots=train_opt['num_shots'],
num_queries=train_opt['num_queries'],
epoch_size=train_opt['iteration'])
valid_loader = DataLoader(dataset_valid,
num_tasks=eval_opt['batch_size'],
num_ways=eval_opt['num_ways'],
num_shots=eval_opt['num_shots'],
num_queries=eval_opt['num_queries'],
epoch_size=eval_opt['iteration'])
test_loader = DataLoader(dataset_test,
num_tasks=eval_opt['batch_size'],
num_ways=eval_opt['num_ways'],
num_shots=eval_opt['num_shots'],
num_queries=eval_opt['num_queries'],
epoch_size=eval_opt['iteration'])
data_loader = {'train': train_loader,
'val': valid_loader,
'test': test_loader}
# create trainer
trainer = DPGNTrainer(enc_module=enc_module,
gnn_module=gnn_module,
data_loader=data_loader,
log=logger,
arg=args_opt,
config=config,
best_step=best_step)
if args_opt.mode == 'train':
trainer.train()
elif args_opt.mode == 'eval':
trainer.eval()
else:
print('select a mode')
exit()
def train_net(net,
epochs=1,
data_dir='data/',
n_classes=3,
lr=0.1,
val_percent=0.1,
save_cp=True,
gpu=True):
## path to save images
output_dir = 'samples/'
train_groundtruth = os.path.join(output_dir, 'train_groundtruth')
train_input = os.path.join(output_dir, 'train_input')
train_output = os.path.join(output_dir, 'train_output')
test_groundtruth = os.path.join(output_dir, 'test_groundtruth')
test_input = os.path.join(output_dir, 'test_input')
test_output = os.path.join(output_dir, 'test_output')
# load data
loader = DataLoader(data_dir)
#N_train = loader.n_train()
N_train = 160
## change to MSEloss adam
criterion = nn.MSELoss()
optimizer = optim.Adam(
net.parameters(),
#lr=lr,
#momentum=0.99,
weight_decay=0.0005)
training_time = time.time()
for epoch in range(epochs):
print('Epoch %d/%d' % (epoch + 1, epochs))
print('Training...')
net.train()
loader.setMode('train')
epoch_loss = 0
## load data
for j, (img, label) in enumerate(loader):
image = torch.tensor(img) # [160,4,128,128]
label = torch.tensor(label) # [160,3,128,128]
if gpu:
image = image.cuda()
label = label.cuda()
batch = 16
for i in range(0, int(N_train / batch)):
## get inputs x with batch 16 [16,4,128,128] [16,3,128,128]
train_x = image[i * batch:(i + 1) * batch, :, :, :]
train_y = label[i * batch:(i + 1) * batch, :, :, :]
pred = net(train_x.float())
optimizer.zero_grad()
loss = criterion(pred, train_y.float())
loss.backward()
optimizer.step()
epoch_loss += loss.item()
print('Training sample %d / %d - Loss: %.6f' %
((i + 1) * batch, N_train, loss.item()))
print('Epoch %d finished! - Loss: %.6f' %
(epoch + 1, epoch_loss / i))
print('End of training. Time Taken: %d sec.' %
(time.time() - training_time))
## image should be [128,128,3]
## Can't call numpy() on Variable that requires grad. Use var.detach().numpy() instead.
plot_label = np.resize(label[-1, :, :, :], (128, 128, 3))
plot_image = np.resize(image[-1, 0:3, :, :], (128, 128, 3))
plot_pred = np.resize(pred[-1, :, :, :], (128, 128, 3))
torchvision.utils.save_image(
plot_label,
os.path.join(train_groundtruth, '{}.png').format('train_groundtruth'))
torchvision.utils.save_image(
plot_image,
os.path.join(train_input, '{}.png').format('train_input'))
torchvision.utils.save_image(
plot_pred,
os.path.join(train_output, '{}.png').format('train_output'))
# displays test images with original and predicted masks after training
loader.setMode('test')
net.eval()
with torch.no_grad():
(img, label) = enumerate(loader)
img_torch = torch.tensor(img) # [6,4,128,128]
if gpu:
img_test = img_torch.cuda()
pred_test = net(img_test) # [6,3,128,128]
# plot test result
for j in range(len(img)):
plot_label_test = np.resize(label[j, :, :, :], (128, 128, 3))
plot_img_test = np.resize(img[j, 0:3, :, :], (128, 128, 3))
plot_pred = np.resize(pred_test[j, :, :, :], (128, 128, 3))
self.plot(plot_label_test, plot_img_test, plot_pred)
torchvision.utils.save_image(
plot_label_test,
os.path.join(test_groundtruth, '{}.png').format('test_groundtruth'))
torchvision.utils.save_image(
plot_img_test,
os.path.join(test_input, '{}.png').format('test_input'))
torchvision.utils.save_image(
plot_pred,
os.path.join(test_output, '{}.png').format('test_output'))
def plot(self, img, label, pred):
plt.subplot(1, 3, 1)
plt.imshow(img * 255.)
plt.subplot(1, 3, 2)
plt.imshow(label * 255.)
plt.subplot(1, 3, 3)
#plt.imshow(pred.cpu().detach().numpy().squeeze()*255.)
plt.imshow(pred * 255.)
plt.show()
def get_train_data(input_path, target_path):
return DataLoader(input_path, target_path, 'train')
help='path to corpus dir')
parser.add_argument('-src',
'--corpus-name',
type=str,
default='data.txt',
help='path to corpus data')
parser.add_argument('--save-dir',
type=str,
default='./data/',
help='path to save processed data')
parser.add_argument('--pre-w2v', type=str, default='../data/w2v')
args = parser.parse_args()
args.corpus_data = args.corpus_dir + args.corpus_name
corpus = Corpus(args.corpus_data, args.pre_w2v, args.save_dir, train_dev=0)
dl = DataLoader(args.save_dir, batch_size=128, train_dev=0)()
# dl_train, dl_test = train_test_split(dl, test_size=0.33)
pre_w2v = torch.load(args.save_dir + 'pre_w2v')
pre_w2v = torch.Tensor(pre_w2v).to(device)
model_ckpt = torch.load(os.path.join(
args.save_dir, '{}.pyt'.format("Transformer_NER_best")),
map_location=torch.device(device))
config = load_obj(args.save_dir + 'Config.json')
model = Transformer_Mix(config, pre_w2v).to(device)
model.load_state_dict(model_ckpt['model'])
# pred_tags = []
# true_tags = []
# loss_epoch_test, f1_cls, f1_tgt, f1_tgt_merged = evaluate_f1(model, dl_test, args.save_dir, verbose=1)
