def setUp(self):
# Set up the objects needed to skin a poseinfer model
self.pi_model = poseinfer.Model(self.model_path)
self.pi_pose_params = poseinfer.PoseParams(22)
# And those needed to skin a python model
self.py_model = load_model(self.model_path)
def build(self, includes):
"""
Build up a model object and attach it to the request object.
The goal is that all database activity will be concentrated here.
"""
cherrypy.request.model = load_model(includes)
def score_images(image_files, outstream):
_log.info('Opening model %s' % options.model_file)
mod = model.load_model(options.model_file)
results = [] # list of (filename, score)
for imfile in image_files:
imfile = imfile.strip()
if imfile == '':
continue
image = cv2.imread(imfile)
if image is None:
_log.warn('Could not open %s' % imfile)
continue
score, attr = mod.score(image, do_filtering=False)
results.append((imfile, score))
if len(results) % 1000 == 0:
_log.info('Scored %i images' % len(results))
results = sorted(results, key=lambda x: -x[1])
outstream.write('\n'.join(['%s,%.5f' % x for x in results]))
def train(output_directory, log_directory, checkpoint_path, warm_start, warm_start_force, n_gpus,
rank, group_name, hparams):
"""Training and validation logging results to tensorboard and stdout
Params
------
output_directory (string): directory to save checkpoints
log_directory (string) directory to save tensorboard logs
checkpoint_path(string): checkpoint path
n_gpus (int): number of gpus
rank (int): rank of current gpu
hparams (object): comma separated list of "name=value" pairs.
"""
# setup distributed
hparams.n_gpus = n_gpus
hparams.rank = rank
if hparams.distributed_run:
init_distributed(hparams, n_gpus, rank, group_name)
# reproducablilty stuffs
torch.manual_seed(hparams.seed)
torch.cuda.manual_seed(hparams.seed)
# initialize blank model
model = load_model(hparams)
model.eval()
learning_rate = hparams.learning_rate
# (optional) show the names of each layer in model, mainly makes it easier to copy/paste what you want to adjust
if hparams.print_layer_names_during_startup:
print(*[f"Layer{i} = "+str(x[0])+" "+str(x[1].shape) for i,x in enumerate(list(model.named_parameters()))], sep="\n")
# (optional) Freeze layers by disabling grads
if len(hparams.frozen_modules):
for layer, params in list(model.named_parameters()):
if any(layer.startswith(module) for module in hparams.frozen_modules):
params.requires_grad = False
print(f"Layer: {layer} has been frozen")
# define optimizer (any params without requires_grad are ignored)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=learning_rate, weight_decay=hparams.weight_decay)
#optimizer = apexopt.FusedAdam(model.parameters(), lr=learning_rate, weight_decay=hparams.weight_decay)
if hparams.fp16_run:
model, optimizer = amp.initialize(model, optimizer, opt_level='O2')
if hparams.distributed_run:
model = apply_gradient_allreduce(model)
criterion = Tacotron2Loss(hparams)
logger = prepare_directories_and_logger(
output_directory, log_directory, rank)
# Load checkpoint if one exists
best_validation_loss = 0.8 # used to see when "best_model" should be saved, default = 0.4, load_checkpoint will update to last best value.
iteration = 0
epoch_offset = 0
_learning_rate = 1e-3
saved_lookup = None
if checkpoint_path is not None:
if warm_start:
model, iteration, saved_lookup = warm_start_model(
checkpoint_path, model, hparams.ignore_layers)
elif warm_start_force:
model, iteration, saved_lookup = warm_start_force_model(
checkpoint_path, model)
else:
model, optimizer, _learning_rate, iteration, best_validation_loss, saved_lookup = load_checkpoint(
checkpoint_path, model, optimizer)
if hparams.use_saved_learning_rate:
learning_rate = _learning_rate
iteration += 1 # next iteration is iteration + 1
print('Model Loaded')
# define datasets/dataloaders
train_loader, valset, collate_fn, train_sampler, trainset = prepare_dataloaders(hparams, saved_lookup)
epoch_offset = max(0, int(iteration / len(train_loader)))
speaker_lookup = trainset.speaker_ids
# load and/or generate global_mean
if hparams.drop_frame_rate > 0.:
if rank != 0: # if global_mean not yet calcuated, wait for main thread to do it
while not os.path.exists(hparams.global_mean_npy): time.sleep(1)
global_mean = calculate_global_mean(train_loader, hparams.global_mean_npy, hparams)
hparams.global_mean = global_mean
model.global_mean = global_mean
# define scheduler
use_scheduler = 0
if use_scheduler:
scheduler = ReduceLROnPlateau(optimizer, factor=0.1**(1/5), patience=10)
model.train()
is_overflow = False
validate_then_terminate = 0
if validate_then_terminate:
val_loss = validate(model, criterion, valset, iteration,
hparams.batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank)
raise Exception("Finished Validation")
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
rolling_loss = StreamingMovingAverage(min(int(len(train_loader)), 200))
# ================ MAIN TRAINNIG LOOP! ===================
for epoch in tqdm(range(epoch_offset, hparams.epochs), initial=epoch_offset, total=hparams.epochs, desc="Epoch:", position=1, unit="epoch"):
tqdm.write("Epoch:{}".format(epoch))
if hparams.distributed_run: # shuffles the train_loader when doing multi-gpu training
train_sampler.set_epoch(epoch)
start_time = time.time()
# start iterating through the epoch
for i, batch in tqdm(enumerate(train_loader), desc="Iter: ", smoothing=0, total=len(train_loader), position=0, unit="iter"):
# run external code every epoch, allows the run to be adjusting without restarts
if (iteration % 1000 == 0 or i==0):
try:
with open("run_every_epoch.py") as f:
internal_text = str(f.read())
if len(internal_text) > 0:
print(internal_text)
#code = compile(internal_text, "run_every_epoch.py", 'exec')
ldict = {'iteration': iteration}
exec(internal_text, globals(), ldict)
print("Custom code excecuted\nPlease remove code if it was intended to be ran once.")
else:
print("No Custom code found, continuing without changes.")
except Exception as ex:
print(f"Custom code FAILED to run!\n{ex}")
globals().update(ldict)
locals().update(ldict)
print("decay_start is ",decay_start)
print("A_ is ",A_)
print("B_ is ",B_)
print("C_ is ",C_)
print("min_learning_rate is ",min_learning_rate)
print("epochs_between_updates is ",epochs_between_updates)
print("drop_frame_rate is ",drop_frame_rate)
print("p_teacher_forcing is ",p_teacher_forcing)
print("teacher_force_till is ",teacher_force_till)
print("val_p_teacher_forcing is ",val_p_teacher_forcing)
print("val_teacher_force_till is ",val_teacher_force_till)
print("grad_clip_thresh is ",grad_clip_thresh)
if epoch % epochs_between_updates == 0 or epoch_offset == epoch:
#if None:
tqdm.write("Old learning rate [{:.6f}]".format(learning_rate))
if iteration < decay_start:
learning_rate = A_ + C_
else:
iteration_adjusted = iteration - decay_start
learning_rate = (A_*(e**(-iteration_adjusted/B_))) + C_
learning_rate = max(min_learning_rate, learning_rate) # output the largest number
tqdm.write("Changing Learning Rate to [{:.6f}]".format(learning_rate))
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
# /run external code every epoch, allows the run to be adjusting without restarts/
model.zero_grad()
x, y = model.parse_batch(batch) # move batch to GPU (async)
y_pred = model(x, teacher_force_till=teacher_force_till, p_teacher_forcing=p_teacher_forcing, drop_frame_rate=drop_frame_rate)
loss, gate_loss = criterion(y_pred, y)
if hparams.distributed_run:
reduced_loss = reduce_tensor(loss.data, n_gpus).item()
reduced_gate_loss = reduce_tensor(gate_loss.data, n_gpus).item()
else:
reduced_loss = loss.item()
reduced_gate_loss = gate_loss.item()
if hparams.fp16_run:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
if hparams.fp16_run:
grad_norm = torch.nn.utils.clip_grad_norm_(
amp.master_params(optimizer), grad_clip_thresh)
is_overflow = math.isinf(grad_norm) or math.isnan(grad_norm)
else:
grad_norm = torch.nn.utils.clip_grad_norm_(
model.parameters(), grad_clip_thresh)
optimizer.step()
for j, param_group in enumerate(optimizer.param_groups):
learning_rate = (float(param_group['lr'])); break
if iteration < decay_start:
learning_rate = A_ + C_
else:
iteration_adjusted = iteration - decay_start
learning_rate = (A_*(e**(-iteration_adjusted/B_))) + C_
learning_rate = max(min_learning_rate, learning_rate) # output the largest number
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
if not is_overflow and rank == 0:
duration = time.time() - start_time
average_loss = rolling_loss.process(reduced_loss)
tqdm.write("{} [Train_loss {:.4f} Avg {:.4f}] [Gate_loss {:.4f}] [Grad Norm {:.4f}] "
"[{:.2f}s/it] [{:.3f}s/file] [{:.7f} LR]".format(
iteration, reduced_loss, average_loss, reduced_gate_loss, grad_norm, duration, (duration/(hparams.batch_size*n_gpus)), learning_rate))
if iteration % 20 == 0:
diagonality, avg_prob = alignment_metric(x, y_pred)
logger.log_training(
reduced_loss, grad_norm, learning_rate, duration, iteration, teacher_force_till, p_teacher_forcing, diagonality=diagonality, avg_prob=avg_prob)
else:
logger.log_training(
reduced_loss, grad_norm, learning_rate, duration, iteration, teacher_force_till, p_teacher_forcing)
start_time = time.time()
if is_overflow and rank == 0:
tqdm.write("Gradient Overflow, Skipping Step")
if not is_overflow and ((iteration % (hparams.iters_per_checkpoint/1) == 0) or (os.path.exists(save_file_check_path))):
# save model checkpoint like normal
if rank == 0:
checkpoint_path = os.path.join(
output_directory, "checkpoint_{}".format(iteration))
save_checkpoint(model, optimizer, learning_rate, iteration, hparams, best_validation_loss, average_loss, speaker_lookup, checkpoint_path)
if not is_overflow and ((iteration % int((hparams.iters_per_validation)/1) == 0) or (os.path.exists(save_file_check_path)) or (iteration < 1000 and (iteration % 250 == 0))):
if rank == 0 and os.path.exists(save_file_check_path):
os.remove(save_file_check_path)
# perform validation and save "best_model" depending on validation loss
val_loss = validate(model, criterion, valset, iteration,
hparams.val_batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank, val_teacher_force_till, val_p_teacher_forcing, teacher_force=1) #teacher_force
val_loss = validate(model, criterion, valset, iteration,
hparams.val_batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank, val_teacher_force_till, val_p_teacher_forcing, teacher_force=2) #infer
val_loss = validate(model, criterion, valset, iteration,
hparams.val_batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank, val_teacher_force_till, val_p_teacher_forcing, teacher_force=0) #validate (0.8 forcing)
if use_scheduler:
scheduler.step(val_loss)
if (val_loss < best_validation_loss):
best_validation_loss = val_loss
if rank == 0:
checkpoint_path = os.path.join(output_directory, "best_model")
save_checkpoint(model, optimizer, learning_rate, iteration, hparams, best_validation_loss, average_loss, speaker_lookup, checkpoint_path)
iteration += 1
def run_TED1104(
model_dir,
fp16: bool,
enable_evasion: bool,
show_current_control: bool,
num_parallel_sequences: int = 1,
evasion_score=1000,
enable_segmentation: bool = False,
) -> None:
"""
Generate dataset exampled from a human playing a videogame
HOWTO:
Set your game in windowed mode
Set your game to 1600x900 resolution
Move the game window to the top left corner, there should be a blue line of 1 pixel in the left bezel of your
screen and the window top bar should start in the top bezel of your screen.
Let the AI play the game!
Controls:
Push QE to exit
Push L to see the input images
Push and hold J to use to use manual control
Input:
- model_dir: Directory where the model to use is stored (model.bin and model_hyperparameters.json files)
- enable_evasion: automatic evasion maneuvers when the car gets stuck somewhere. Note: It adds computation time
- show_current_control: Show a window with text that indicates if the car is currently being driven by
the AI or a human
- num_parallel_sequences: num_parallel_sequences to record, is the number is larger the recorded sequence of images
will be updated faster and the model will use more recent images as well as being able to do more iterations
per second. However if num_parallel_sequences is too high it wont be able to update the sequences with 1/10 secs
between images (default capturate to generate training examples).
-evasion_score: Mean squared error value between images to activate the evasion maneuvers
-enable_segmentation: Image segmentation will be performed using a pretrained model. Cars, persons, bikes.. will be
highlighted to help the model to identify them.
Output:
"""
if enable_segmentation:
image_segmentation = ImageSegmentation(model_name="fcn_resnet101",
device=device,
fp16=fp16)
else:
image_segmentation = None
show_what_ai_sees: bool = False
fp16: bool
model: TEDD1104
model = load_model(save_dir=model_dir, device=device, fp16=fp16)
model.eval()
stop_recording: threading.Event = threading.Event()
th_img: threading.Thread = threading.Thread(
target=screen_recorder.img_thread, args=[stop_recording])
th_seq: threading.Thread = threading.Thread(
target=screen_recorder.multi_image_sequencer_thread,
args=[stop_recording, num_parallel_sequences],
)
th_img.setDaemon(True)
th_seq.setDaemon(True)
th_img.start()
# Wait to launch the image_sequencer_thread, it needs the img_thread to be running
time.sleep(5)
th_seq.start()
if show_current_control:
root = Tk()
var = StringVar()
var.set("T.E.D.D. 1104 Driving")
l = Label(root, textvariable=var, fg="green", font=("Courier", 44))
l.pack()
last_time: float = time.time()
model_prediction: np.ndarray = np.asarray([0])
score: np.float = np.float(0)
last_num: int = 0
while True:
while (
last_num == screen_recorder.num
): # Don't run the same sequence again, the resulted key will be the same
time.sleep(0.0001)
last_num = screen_recorder.num
if enable_segmentation:
img_seq: np.ndarray = image_segmentation.add_segmentation(
np.copy(screen_recorder.seq))
else:
img_seq: np.ndarray = np.copy(screen_recorder.seq)
keys = key_check()
if not "J" in keys:
X: torch.Tensor = torch.from_numpy(
reshape_x(np.array([img_seq]), fp=16 if fp16 else 32))
model_prediction = model.predict(X.to(device)).cpu().numpy()
select_key(int(model_prediction[0]))
if show_current_control:
var.set("T.E.D.D. 1104 Driving")
l.config(fg="green")
root.update()
if enable_evasion:
score = mse(img_seq[0], img_seq[4])
if score < evasion_score:
if show_current_control:
var.set("Evasion maneuver")
l.config(fg="blue")
root.update()
select_key(4)
time.sleep(1)
if np.random.rand() > 0.5:
select_key(6)
else:
select_key(8)
time.sleep(0.2)
if show_current_control:
var.set("T.E.D.D. 1104 Driving")
l.config(fg="green")
root.update()
else:
if show_current_control:
var.set("Manual Control")
l.config(fg="red")
root.update()
if show_what_ai_sees:
cv2.imshow("window1", img_seq[0])
cv2.waitKey(1)
cv2.imshow("window2", img_seq[1])
cv2.waitKey(1)
cv2.imshow("window3", img_seq[2])
cv2.waitKey(1)
cv2.imshow("window4", img_seq[3])
cv2.waitKey(1)
cv2.imshow("window5", img_seq[4])
cv2.waitKey(1)
if "Q" in keys and "E" in keys:
print("\nStopping...")
stop_recording.set()
th_seq.join()
th_img.join()
if show_what_ai_sees:
cv2.destroyAllWindows()
break
if "L" in keys:
time.sleep(0.1) # Wait for key release
if show_what_ai_sees:
cv2.destroyAllWindows()
show_what_ai_sees = False
else:
show_what_ai_sees = True
time_it: float = time.time() - last_time
print(
f"Recording at {screen_recorder.fps} FPS\n"
f"Actions per second {None if time_it==0 else 1/time_it}\n"
f"Key predicted by nn: {key_press(model_prediction[0])}\n"
f"Difference from img 1 to img 5 {None if not enable_evasion else score}\n"
f"Push QE to exit\n"
f"Push L to see the input images\n"
f"Push J to use to use manual control\n",
end="\r",
)
last_time = time.time()
def __init__(
self,
config,
data_loader,
val_data_loader=None,
):
# occupancy only for 3D Match dataset. For ScanNet, use RGB 3 channels.
num_feats = 1
# Model initialization
Model = load_model(config.model)
model = Model(
num_feats,
config.model_n_out,
bn_momentum=config.bn_momentum,
normalize_feature=config.normalize_feature,
conv1_kernel_size=config.conv1_kernel_size,
D=3)
if config.weights:
checkpoint = torch.load(config.weights)
model.load_state_dict(checkpoint['state_dict'])
logging.info(model)
self.config = config
self.model = model
self.max_epoch = config.max_epoch
self.save_freq = config.save_freq_epoch
self.val_max_iter = config.val_max_iter
self.val_epoch_freq = config.val_epoch_freq
self.best_val_metric = config.best_val_metric
self.best_val_epoch = -np.inf
self.best_val = -np.inf
if config.use_gpu and not torch.cuda.is_available():
logging.warning('Warning: There\'s no CUDA support on this machine, '
'training is performed on CPU.')
raise ValueError('GPU not available, but cuda flag set')
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
self.optimizer = getattr(optim, config.optimizer)(
model.parameters(),
lr=config.lr,
momentum=config.momentum,
weight_decay=config.weight_decay)
self.scheduler = optim.lr_scheduler.ExponentialLR(
self.optimizer, config.exp_gamma)
self.start_epoch = 1
self.checkpoint_dir = config.out_dir
ensure_dir(self.checkpoint_dir)
json.dump(
config,
open(os.path.join(self.checkpoint_dir, 'config.json'), 'w'),
indent=4,
sort_keys=False)
self.iter_size = config.iter_size
self.batch_size = data_loader.batch_size
self.data_loader = data_loader
self.val_data_loader = val_data_loader
self.test_valid = True if self.val_data_loader is not None else False
self.log_step = int(np.sqrt(self.config.batch_size))
self.model = self.model.to(self.device)
self.writer = SummaryWriter(logdir=config.out_dir)
if config.resume is not None:
if osp.isfile(config.resume):
logging.info(
"=> loading checkpoint '{}'".format(config.resume))
state = torch.load(config.resume)
self.start_epoch = state['epoch']
model.load_state_dict(state['state_dict'])
self.scheduler.load_state_dict(state['scheduler'])
self.optimizer.load_state_dict(state['optimizer'])
if 'best_val' in state.keys():
self.best_val = state['best_val']
self.best_val_epoch = state['best_val_epoch']
self.best_val_metric = state['best_val_metric']
else:
raise ValueError(f"=> no checkpoint found at '{config.resume}'")
def main(config):
test_loader = make_data_loader(
config, config.test_phase, 1, num_threads=config.test_num_thread, shuffle=True)
num_feats = 1
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
Model = load_model(config.model)
model = Model(num_feats, config.model_n_out, config=config)
checkpoint = torch.load(config.save_dir + '/checkpoint.pth')
model.load_state_dict(checkpoint['state_dict'])
model = model.to(device)
model.eval()
success_meter, loss_meter, rte_meter, rre_meter = AverageMeter(), AverageMeter(
), AverageMeter(), AverageMeter()
data_timer, feat_timer, reg_timer = Timer(), Timer(), Timer()
test_iter = test_loader.__iter__()
N = len(test_iter)
n_gpu_failures = 0
# downsample_voxel_size = 2 * config.voxel_size
for i in range(len(test_iter)):
data_timer.tic()
try:
xyz0, xyz1, coord0, coord1, feats0, feats1, matching01, T_gth, len_01 = test_iter.next(
)
except ValueError:
n_gpu_failures += 1
logging.info(f"# Erroneous GPU Pair {n_gpu_failures}")
continue
data_timer.toc()
xyz0np, xyz1np = xyz0.numpy(), xyz1.numpy()
pcd0 = make_open3d_point_cloud(xyz0np)
pcd1 = make_open3d_point_cloud(xyz1np)
with torch.no_grad():
feat_timer.tic()
sinput0 = ME.SparseTensor(feats0, coords=coord0).to(device)
F0 = model(sinput0).F.detach()
sinput1 = ME.SparseTensor(feats1, coords=coord1).to(device)
F1 = model(sinput1).F.detach()
feat_timer.toc()
feat0 = make_open3d_feature(F0, 32, F0.shape[0])
feat1 = make_open3d_feature(F1, 32, F1.shape[0])
reg_timer.tic()
distance_threshold = config.voxel_size * 1.0
ransac_result = o3d.registration_ransac_based_on_feature_matching(
pcd0, pcd1, feat0, feat1, distance_threshold,
o3d.TransformationEstimationPointToPoint(False), 4, [
o3d.CorrespondenceCheckerBasedOnEdgeLength(0.9),
o3d.CorrespondenceCheckerBasedOnDistance(distance_threshold)
], o3d.RANSACConvergenceCriteria(4000000, 10000))
T_ransac = torch.from_numpy(ransac_result.transformation.astype(np.float32))
reg_timer.toc()
loss_ransac = corr_dist(T_ransac, T_gth, xyz0, xyz1, weight=None, max_dist=1)
# Translation error
rte = np.linalg.norm(T_ransac[:3, 3] - T_gth[:3, 3])
rre = np.arccos((np.trace(T_ransac[:3, :3].t() @ T_gth[:3, :3]) - 1) / 2)
# Check if the ransac was successful. successful if rte < 2m and rre < 5◦
# http://openaccess.thecvf.com/content_ECCV_2018/papers/Zi_Jian_Yew_3DFeat-Net_Weakly_Supervised_ECCV_2018_paper.pdf
if rte < 2:
rte_meter.update(rte)
if not np.isnan(rre) and rre < np.pi / 180 * 5:
rre_meter.update(rre)
if rte < 2 and not np.isnan(rre) and rre < np.pi / 180 * 5:
success_meter.update(1)
else:
success_meter.update(0)
logging.info(f"Failed with RTE: {rte}, RRE: {rre}")
loss_meter.update(loss_ransac)
if i % 10 == 0:
logging.info(
f"{i} / {N}: Data time: {data_timer.avg}, Feat time: {feat_timer.avg}," +
f" Reg time: {reg_timer.avg}, Loss: {loss_meter.avg}, RTE: {rte_meter.avg}," +
f" RRE: {rre_meter.avg}, Success: {success_meter.sum} / {success_meter.count}" +
f" ({success_meter.avg * 100} %)"
)
data_timer.reset()
feat_timer.reset()
reg_timer.reset()
logging.info(
f"Total loss: {loss_meter.avg}, RTE: {rte_meter.avg}, var: {rte_meter.var}," +
f" RRE: {rre_meter.avg}, var: {rre_meter.var}, Success: {success_meter.sum} " +
f"/ {success_meter.count} ({success_meter.avg * 100} %)"
)
def measure(output_directory, log_directory, checkpoint_path, warm_start,
n_gpus, rank, group_name, hparams):
"""Handles all the validation scoring and printing"""
stft = TacotronSTFT(hparams.filter_length, hparams.hop_length,
hparams.win_length, hparams.n_mel_channels,
hparams.sampling_rate, hparams.mel_fmin,
hparams.mel_fmax)
mellotron = load_model(hparams).cuda().eval()
mellotron.load_state_dict(torch.load(checkpoint_path)['state_dict'])
waveglow_path = '/media/arsh/New Volume/Models/speech/waveglow_256channels_v4.pt'
waveglow = torch.load(waveglow_path)['model'].cuda().eval()
denoiser = Denoiser(waveglow).cuda().eval()
arpabet_dict = cmudict.CMUDict('data/cmu_dictionary')
audio_paths = 'filelists/libritts_train_clean_100_audiopath_text_sid_atleast5min_val_filelist.txt'
dataloader = TextMelLoader(audio_paths, hparams)
datacollate = TextMelCollate(1)
speaker_ids = TextMelLoader(
"filelists/libritts_train_clean_100_audiopath_text_sid_shorterthan10s_atleast5min_train_filelist.txt",
hparams).speaker_ids
speakers = pd.read_csv('filelists/libritts_speakerinfo.txt',
engine='python',
header=None,
comment=';',
sep=' *\| *',
names=['ID', 'SEX', 'SUBSET', 'MINUTES', 'NAME'])
speakers['MELLOTRON_ID'] = speakers['ID'].apply(
lambda x: speaker_ids[x] if x in speaker_ids else -1)
female_speakers = cycle(
speakers.query("SEX == 'F' and MINUTES > 20 and MELLOTRON_ID >= 0")
['MELLOTRON_ID'].sample(frac=1).tolist())
male_speakers = cycle(
speakers.query("SEX == 'M' and MINUTES > 20 and MELLOTRON_ID >= 0")
['MELLOTRON_ID'].sample(frac=1).tolist())
file_idx = 0
MEL_DTW = []
TPP_DTW = []
RAND_DTW = []
logSpecDbConst = 10.0 / math.log(10.0) * math.sqrt(2.0)
while file_idx < len(dataloader):
audio_path, text, sid = dataloader.audiopaths_and_text[file_idx]
# get audio path, encoded text, pitch contour and mel for gst
text_encoded = torch.LongTensor(
text_to_sequence(text, hparams.text_cleaners,
arpabet_dict))[None, :].cuda()
pitch_contour = dataloader[file_idx][3][None].cuda()
mel = load_mel(audio_path, stft)
fs, audio = read(audio_path)
# load source data to obtain rhythm using tacotron 2 as a forced aligner
x, y = mellotron.parse_batch(datacollate([dataloader[file_idx]]))
with torch.no_grad():
# get rhythm (alignment map) using tacotron 2
mel_outputs, mel_outputs_postnet, gate_outputs, rhythm, gst, tpse_gst = mellotron.forward(
x)
rhythm = rhythm.permute(1, 0, 2)
speaker_id = next(female_speakers) if np.random.randint(2) else next(
male_speakers)
speaker_id = torch.LongTensor([speaker_id]).cuda()
with torch.no_grad():
mel_outputs, mel_outputs_postnet, gate_outputs, _ = mellotron.inference_noattention(
(text_encoded, mel, speaker_id, pitch_contour, rhythm),
with_tpse=False)
with torch.no_grad():
audio_mel = denoiser(
waveglow.infer(mel_outputs_postnet, sigma=0.8), 0.01)[:, 0]
with torch.no_grad():
mel_outputs, mel_outputs_postnet, gate_outputs, _ = mellotron.inference_noattention(
(text_encoded, mel, speaker_id, pitch_contour, rhythm),
with_tpse=True)
with torch.no_grad():
audio_tpp = denoiser(
waveglow.infer(mel_outputs_postnet, sigma=0.8), 0.01)[:, 0]
with torch.no_grad():
mel_outputs, mel_outputs_postnet, gate_outputs, _ = mellotron.inference_noattention(
(text_encoded, np.random.randint(
0, 9), speaker_id, pitch_contour, rhythm),
with_tpse=False)
with torch.no_grad():
audio_rand = denoiser(
waveglow.infer(mel_outputs_postnet, sigma=0.8), 0.01)[:, 0]
audio = np.pad(audio, 128)
MEL_DTW.append(
logSpecDbConst *
np.log(dtw(audio_mel.data.cpu().numpy(), audio, eucCepDist)[0]))
TPP_DTW.append(
logSpecDbConst *
np.log(dtw(audio_tpp.data.cpu().numpy(), audio, eucCepDist)[0]))
RAND_DTW.append(
logSpecDbConst *
np.log(dtw(audio_rand.data.cpu().numpy(), audio, eucCepDist)[0]))
print(MEL_DTW[-1], TPP_DTW[-1], RAND_DTW[-1])
print("MEL DTW, Mean: ", np.mean(MEL_DTW), " SD: ", np.std(MEL_DTW))
print("TPP DTW, Mean: ", np.mean(TPP_DTW), " SD: ", np.std(TPP_DTW))
print("RAND DTW, Mean: ", np.mean(RAND_DTW), " SD: ", np.std(RAND_DTW))
file_idx += 1
"""
from __future__ import print_function
import os
import sys
import chainer
import numpy
from argument import get_args
from model import load_model
from files import load_image, save_features, mkdir, grep_images
if __name__ == '__main__':
args, xp = get_args()
forward, in_size, mean_image = load_model(args)
mkdir(args.dst)
msg = True
ps = []
path_list = grep_images(args.src)
total = len(path_list)
x_batch = numpy.ndarray((args.batchsize, 3, in_size, in_size), dtype=numpy.float32)
for i, path in enumerate(path_list):
image = load_image(path, in_size, mean_image)
x_batch[i % args.batchsize] = image
ps.append(path)
if i == 0 and i != total - 1:
continue
"""
# API Dependencies
import pickle
import json
import numpy as np
from model import load_model, make_prediction
from flask import Flask, request, jsonify
# Application definition
app = Flask(__name__)
# Load our model into memory.
# Please update this path to reflect your own trained model.
static_model = load_model(
path_to_model='assets/trained-models/multiple_linear_regression2.pkl')
print('-' * 40)
print('Model succesfully loaded')
print('-' * 40)
# Define the API's interface.
# Here the 'model_prediction()' function will be called when a POST request
# is sent to our interface located at:
# http:{Host-machine-ip-address}:5000/api_v0.1
@app.route('/api_v0.1', methods=['POST'])
def model_prediction():
# We retrieve the data payload of the POST request
data = request.get_json(force=True)
# We then preprocess our data, and use our pretrained model to make a
from flask import Flask, jsonify, request
from model import load_model
app = Flask(__name__)
model = load_model()
@app.route("/")
def index():
return f"Serving a {model.__class__.__name__} model using Flask."
@app.route("/predict", methods=["POST"])
def predict():
body = request.get_json(force=True)
prediction = model.predict(body["X"])
return jsonify({"y": prediction.tolist()})
if __name__ == "__main__":
app.run(host="0.0.0.0", port="8000")
print('Step1: Dataset is loaded successfully!')
preprocessed_data = preprocessing(data)
print('Step2: Data preprocessing done successfully!')
train, test = train_test_split(preprocessed_data)
print('Step3: Data splitted into train and test successfully!')
train_X, train_Y, test_X, test_Y, vectorizer = feature_extraction(
train, test)
trained_model = model_training(train_X, train_Y)
print('Step4: Model trained successfully successfully!')
accuracy = model_testing(test_X, test_Y, trained_model)
vec_classifier = Pipeline([('vectorizer', vectorizer),
('classifier', trained_model)])
save_model(vec_classifier)
print('Step5: Model is deployed successfully')
loaded_model = load_model('saved_models/model.pkl')
data = ["Aortic aneurysm", "AR", "SAS", "HBP", "hipertynson"]
res = predict(data, loaded_model)
print(res)
except Exception as e:
print('Error occured in the main loop: ', e)
def main(_run, _log):
args = argparse.Namespace(**_run.config)
args = post_config_hook(args, _run)
args.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
root = "./datasets"
simclr_model = load_model(args, reload_model=True)
simclr_model = simclr_model.to(args.device)
simclr_model.eval()
## Logistic Regression
n_classes = 10 # stl-10
model = LogisticRegression(simclr_model.n_features, n_classes)
model = model.to(args.device)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
criterion = torch.nn.CrossEntropyLoss()
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
if args.dataset == "STL10":
train_dataset = torchvision.datasets.STL10(
root, split="train", download=True, transform=torchvision.transforms.ToTensor()
)
test_dataset = torchvision.datasets.STL10(
root, split="test", download=True, transform=torchvision.transforms.ToTensor()
)
elif args.dataset == "CIFAR10":
train_dataset = torchvision.datasets.CIFAR10(
root, train=True, download=True, transform=transform
)
test_dataset = torchvision.datasets.CIFAR10(
root, train=False, download=True, transform=transform
)
else:
raise NotImplementedError
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.logistic_batch_size,
shuffle=True,
drop_last=True,
num_workers=args.workers,
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=args.logistic_batch_size,
shuffle=False,
drop_last=True,
num_workers=args.workers,
)
for epoch in range(args.logistic_epochs):
loss_epoch, accuracy_epoch = train(args, train_loader, simclr_model, model, criterion, optimizer)
print(f"Epoch [{epoch}/{args.logistic_epochs}]\t Loss: {loss_epoch / len(train_loader)}\t Accuracy: {accuracy_epoch / len(train_loader)}")
# final testing
loss_epoch, accuracy_epoch = test(args, test_loader, simclr_model, model, criterion, optimizer)
print(f"[FINAL]\t Loss: {loss_epoch / len(test_loader)}\t Accuracy: {accuracy_epoch / len(test_loader)}")
def run():
model = load_model(arch, pretrained, use_gpu=use_gpu, num_classes=30, AdaptiveAvgPool=AdaptiveAvgPool, SPP=SPP, num_levels=num_levels, pool_type=pool_type, bilinear=bilinear, stage=stage, SENet=SENet,se_stage=se_stage,se_layers=se_layers, threshold_before_avg = threshold_before_avg)
if use_gpu:
if arch.lower().startswith('alexnet') or arch.lower().startswith('vgg'):
model.features = nn.DataParallel(model.features)
model.cuda()
else:
model = nn.DataParallel(model).cuda()#
#model = nn.DataParallel(model, device_ids=[2]).cuda()
best_prec3 = 0
best_loss1 = 10000
if try_resume:
if os.path.isfile(latest_check):
print("=> loading checkpoint '{}'".format(latest_check))
checkpoint = torch.load(latest_check)
global start_epoch
start_epoch = checkpoint['epoch']
best_prec3 = checkpoint['best_prec3']
best_loss1 = checkpoint['loss1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'"
.format(latest_check))
else:
print("=> no checkpoint found at '{}'".format(latest_check))
cudnn.benchmark = True
if class_aware:
train_set = td.ImageFolder(TRAIN_ROOT, data_transforms(train_transform,input_size, train_scale, test_scale))
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=BATCH_SIZE, shuffle=False,
sampler=ClassAwareSampler.ClassAwareSampler(train_set),
num_workers=INPUT_WORKERS, pin_memory=use_gpu)
else:
train_loader = torch.utils.data.DataLoader(
td.ImageFolder(TRAIN_ROOT, data_transforms(train_transform,input_size, train_scale, test_scale)),
batch_size=BATCH_SIZE, shuffle=True,
num_workers=INPUT_WORKERS, pin_memory=use_gpu)
val_loader = torch.utils.data.DataLoader(
td.ImageFolder(VALIDATION_ROOT, data_transforms('validation',input_size, train_scale, test_scale)),
batch_size=BATCH_SIZE, shuffle=False,
num_workers=INPUT_WORKERS, pin_memory=use_gpu)
criterion = nn.CrossEntropyLoss().cuda() if use_gpu else nn.CrossEntropyLoss()
if if_fc:
if pretrained == 'imagenet' or arch == 'resnet50' or arch == 'resnet18':
ignored_params = list(map(id, model.module.fc.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params,
model.module.parameters())
lr_dicts = [{'params': base_params, 'lr':lr1},
{'params': model.module.fc.parameters(), 'lr':lr2}]
elif pretrained =='places':
if arch == 'preact_resnet50':
lr_dicts = list()
lr_dicts.append({'params': model.module._modules['12']._modules['1'].parameters(), 'lr':lr2})
for _, index in enumerate(model.module._modules):
if index != '12':
lr_dicts.append({'params': model.module._modules[index].parameters(), 'lr':lr1})
else:
for index2,_ in enumerate(model.module._modules[index]):
if index2 !=1:
lr_dicts.append({'params': model.module._modules[index]._modules[str(index2)].parameters(), 'lr':lr1})
elif arch == 'resnet152':
lr_dicts = list()
lr_dicts.append({'params': model.module._modules['10']._modules['1'].parameters(), 'lr':lr2})
for _, index in enumerate(model.module._modules):
if index != '10':
lr_dicts.append({'params': model.module._modules[index].parameters(), 'lr':lr1})
else:
for index2,_ in enumerate(model.module._modules[index]):
if index2 !=1:
lr_dicts.append({'params': model.module._modules[index]._modules[str(index2)].parameters(), 'lr':lr1})
if optim_type == 'Adam':
optimizer = optim.Adam(lr_dicts,
betas=betas, eps=eps, weight_decay=weight_decay)
elif optim_type == 'SGD':
optimizer = optim.SGD(lr_dicts,
momentum=momentum, weight_decay=weight_decay)
else:
if optim_type == 'Adam':
if stage == 1 or se_stage == 1:
# optimizer = optim.Adam(model.module.fc.parameters(), lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
else:
optimizer = optim.Adam(model.parameters(), lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
elif optim_type == 'SGD':
if stage == 1 or se_stage == 1:
# if pretrained == 'places' and arch == 'preact_resnet50':
# optimizer = optim.SGD(model.module._modules['12']._modules['1'].parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)
# elif pretrained =='places' and arch == 'resnet152':
# optimizer = optim.SGD(model.module._modules['10']._modules['1'].parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)
# else:
# optimizer = optim.SGD(model.module.fc.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)
optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=lr, momentum=momentum, weight_decay=weight_decay)
else:
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay)
if evaluate:
validate(val_loader, model, criterion)
else:
for epoch in range(start_epoch, epochs):
# train for one epoch
prec3, loss1 = train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
if VALIDATION_ROOT != None:
prec3, loss1 = validate(val_loader, model, criterion, epoch)
# remember best
is_best = loss1 <= best_loss1
best_loss1 = min(loss1, best_loss1)
if epoch % save_freq == 0:
save_checkpoint_epoch({
'epoch': epoch + 1,
'arch': arch,
'state_dict': model.state_dict(),
'best_prec3': best_prec3,
'loss1': loss1
}, epoch+1)
save_checkpoint({
'epoch': epoch + 1,
'arch': arch,
'state_dict': model.state_dict(),
'best_prec3': best_prec3,
'loss1': loss1
}, is_best)
_log = logging.getLogger(__name__)
def choose_thumbnails(video):
video = cv2.VideoCapture(options.video)
mod.choose_thumbnails(video, n=5)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--model', default=None,
help='File containing the model')
parser.add_option('--video', default=None,
help='The video to process')
options, args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
_log.info('Loading model')
mod = model.load_model(options.model)
gc.collect()
objgraph.show_growth()
for i in range(10):
choose_thumbnails(options.video)
gc.collect()
objgraph.show_growth()
_log.info('Done')
from model.operation import Operation
from model.couch import LegoDocument
# TODO: Move this from here
couchdb = Server()
try:
database = couchdb['lego_erp_test']
except:
database = couchdb.create('lego_erp_test')
if not len(couchdb['lego_erp_test']):
from model import load_model
from examples import simplecrm
load_model(database, simplecrm.model)
def index(request):
'''
index.html display the view list and each view operations.
'''
# Get all perspectives
perspectives = {}
for view in Perspective().list(database):
perspectives[view.id] = view
return render_to_response('explorer/index.html', { 'perspectives' : perspectives })
def operation(request, viewid, id):
registration_data = {'ip': ip, 'port': port}
try:
resp = requests.post(REGISTER_URL, data=registration_data)
return resp.status_code == 200
except requests.ConnectionError:
return False
if __name__ == '__main__':
# Setup database connection
client = MongoClient()
db = client.fraud_prediction_service
print "Connected to Mongo database"
# Load model
model = load_model()
print "Loaded predictive model"
# Register for pinging service
ip_address = socket.gethostbyname(socket.gethostname())
print "attempting to register %s:%d" % (ip_address, PORT)
if register_for_ping(ip_address, str(PORT)):
print "Registered with pinging service"
else:
print "Registration with pinging service failed."
# Start Flask app
# 0.0.0.0 is so that the Flask app can receive requests from external
# sources
app.run(host='0.0.0.0', port=PORT, debug=True)
def main(args):
vocab, vocab_inv = load_vocab(args.model_dir)
vocab_source, vocab_target = vocab
vocab_inv_source, vocab_inv_target = vocab_inv
source_dataset, target_dataset = read_data(vocab_source,
vocab_target,
args.source_train,
args.target_train,
args.source_dev,
args.target_dev,
args.source_test,
args.target_test,
reverse_source=True)
source_dataset_train, source_dataset_dev, source_dataset_test = source_dataset
target_dataset_train, target_dataset_dev, target_dataset_test = target_dataset
printb("data #")
if len(source_dataset_train) > 0:
print("train {}".format(len(source_dataset_train)))
if len(source_dataset_dev) > 0:
print("dev {}".format(len(source_dataset_dev)))
if len(source_dataset_test) > 0:
print("test {}".format(len(source_dataset_test)))
print("vocab {} (source)".format(len(vocab_source)))
print("vocab {} (target)".format(len(vocab_target)))
# split into buckets
source_buckets_train = None
if len(source_dataset_train) > 0:
printb("buckets #data (train)")
source_buckets_train, target_buckets_train = make_buckets(
source_dataset_train, target_dataset_train)
if args.buckets_slice is not None:
source_buckets_train = source_buckets_train[:args.buckets_slice +
1]
target_buckets_train = target_buckets_train[:args.buckets_slice +
1]
for size, data in zip(bucket_sizes, source_buckets_train):
print("{} {}".format(size, len(data)))
source_buckets_dev = None
if len(source_dataset_dev) > 0:
printb("buckets #data (dev)")
source_buckets_dev, target_buckets_dev = make_buckets(
source_dataset_dev, target_dataset_dev)
if args.buckets_slice is not None:
source_buckets_dev = source_buckets_dev[:args.buckets_slice + 1]
target_buckets_dev = target_buckets_dev[:args.buckets_slice + 1]
for size, data in zip(bucket_sizes, source_buckets_dev):
print("{} {}".format(size, len(data)))
source_buckets_test = None
if len(source_dataset_test) > 0:
printb("buckets #data (test)")
source_buckets_test, target_buckets_test = make_buckets(
source_dataset_test, target_dataset_test)
if args.buckets_slice is not None:
source_buckets_test = source_buckets_test[:args.buckets_slice + 1]
target_buckets_test = target_buckets_test[:args.buckets_slice + 1]
for size, data in zip(bucket_sizes, source_buckets_test):
print("{} {}".format(size, len(data)))
model = load_model(args.model_dir)
assert model is not None
if args.gpu_device >= 0:
cuda.get_device(args.gpu_device).use()
model.to_gpu()
def mean(l):
return sum(l) / len(l)
with chainer.using_config("train", False):
if source_buckets_train is not None:
printb("WER (train)")
wer_train = compute_error_rate_buckets(model, source_buckets_train,
target_buckets_train,
len(vocab_target),
args.beam_width, args.alpha)
print(mean(wer_train), wer_train)
if source_buckets_dev is not None:
printb("WER (dev)")
wer_dev = compute_error_rate_buckets(model, source_buckets_dev,
target_buckets_dev,
len(vocab_target),
args.beam_width, args.alpha)
print(mean(wer_dev), wer_dev)
if source_buckets_test is not None:
printb("WER (test)")
wer_test = compute_error_rate_buckets(model, source_buckets_test,
target_buckets_test,
len(vocab_target),
args.beam_width, args.alpha)
print(mean(wer_test), wer_test)
args = parser.parse_args()
# load env
import json
from env import make_env
file_args = json.load(open(args.argfile))
env_name = file_args["env_name"]
env_args = file_args["env_args"]
env_args["enable_draw"] = True
test_env = make_env(env_name, env_args)
# load model
import torch
from model import load_model
ckpt = args.ckpt
if args.ckpt:
ckpt = args.ckpt
elif "ckpt" in file_args:
ckpt = file_args["ckpt"]
else:
print("please specify checkpoint")
assert (False)
model = load_model(ckpt)
data = torch.load(ckpt)
if "select_set" in data.keys():
select_set = data["select_set"]
else:
select_set = None
test_model(test_env, model, select_set, args.record, args.random)
def train(output_directory, log_directory, checkpoint_path, warm_start,
warm_start_force, n_gpus, rank, group_name, hparams):
"""Training and validation logging results to tensorboard and stdout
Params
------
output_directory (string): directory to save checkpoints
log_directory (string) directory to save tensorboard logs
checkpoint_path(string): checkpoint path
n_gpus (int): number of gpus
rank (int): rank of current gpu
hparams (object): comma separated list of "name=value" pairs.
"""
# setup distributed
hparams.n_gpus = n_gpus
hparams.rank = rank
if hparams.distributed_run:
init_distributed(hparams, n_gpus, rank, group_name)
# reproducablilty stuffs
torch.manual_seed(hparams.seed)
torch.cuda.manual_seed(hparams.seed)
# initialize blank model
print('Initializing UnTTS...')
model = load_model(hparams)
print('Done')
model.eval()
learning_rate = hparams.learning_rate
# (optional) show the names of each layer in model, mainly makes it easier to copy/paste what you want to adjust
if hparams.print_layer_names_during_startup:
print(*[
f"Layer{i} = " + str(x[0]) + " " + str(x[1].shape)
for i, x in enumerate(list(model.named_parameters()))
],
sep="\n")
# (optional) Freeze layers by disabling grads
if len(hparams.frozen_modules):
for layer, params in list(model.named_parameters()):
if any(
layer.startswith(module)
for module in hparams.frozen_modules):
params.requires_grad = False
print(f"Layer: {layer} has been frozen")
# define optimizer (any params without requires_grad are ignored)
#optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=learning_rate, weight_decay=hparams.weight_decay)
optimizer = apexopt.FusedAdam(filter(lambda p: p.requires_grad,
model.parameters()),
lr=learning_rate,
weight_decay=hparams.weight_decay)
if True and rank == 0:
pytorch_total_params = sum(p.numel() for p in model.parameters())
print("{:,} total parameters in model".format(pytorch_total_params))
pytorch_total_params = sum(p.numel() for p in model.parameters()
if p.requires_grad)
print("{:,} trainable parameters.".format(pytorch_total_params))
if hparams.fp16_run:
model, optimizer = amp.initialize(
model, optimizer, opt_level=f'O{hparams.fp16_run_optlvl}')
if hparams.distributed_run:
model = apply_gradient_allreduce(model)
criterion = Tacotron2Loss(hparams)
logger = prepare_directories_and_logger(hparams, output_directory,
log_directory, rank)
# Load checkpoint if one exists
best_validation_loss = 1e3 # used to see when "best_model" should be saved
n_restarts = 0
checkpoint_iter = 0
iteration = 0
epoch_offset = 0
_learning_rate = 1e-3
saved_lookup = None
global best_val_loss_dict
best_val_loss_dict = None
global best_loss_dict
best_loss_dict = None
global expavg_loss_dict
expavg_loss_dict = None
expavg_loss_dict_iters = 0 # initial iters expavg_loss_dict has been fitted
loss_dict_smoothness = 0.95 # smoothing factor
if checkpoint_path is not None:
if warm_start:
model, iteration, saved_lookup = warm_start_model(
checkpoint_path, model, hparams.ignore_layers)
elif warm_start_force:
model, iteration, saved_lookup = warm_start_force_model(
checkpoint_path, model)
else:
_ = load_checkpoint(checkpoint_path, model, optimizer,
best_val_loss_dict, best_loss_dict)
model, optimizer, _learning_rate, iteration, best_validation_loss, saved_lookup, best_val_loss_dict, best_loss_dict = _
if hparams.use_saved_learning_rate:
learning_rate = _learning_rate
checkpoint_iter = iteration
iteration += 1 # next iteration is iteration + 1
print('Model Loaded')
# define datasets/dataloaders
train_loader, valset, collate_fn, train_sampler, trainset = prepare_dataloaders(
hparams, saved_lookup)
epoch_offset = max(0, int(iteration / len(train_loader)))
speaker_lookup = trainset.speaker_ids
# load and/or generate global_mean
if hparams.drop_frame_rate > 0.:
if rank != 0: # if global_mean not yet calcuated, wait for main thread to do it
while not os.path.exists(hparams.global_mean_npy):
time.sleep(1)
global_mean = calculate_global_mean(train_loader,
hparams.global_mean_npy, hparams)
hparams.global_mean = global_mean
model.global_mean = global_mean
# define scheduler
use_scheduler = 0
if use_scheduler:
scheduler = ReduceLROnPlateau(optimizer,
factor=0.1**(1 / 5),
patience=10)
model.train()
is_overflow = False
validate_then_terminate = 0
if validate_then_terminate:
val_loss = validate(model, criterion, valset, iteration,
hparams.batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank)
raise Exception("Finished Validation")
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
rolling_loss = StreamingMovingAverage(min(int(len(train_loader)), 200))
# ================ MAIN TRAINNIG LOOP! ===================
training = True
while training:
try:
for epoch in tqdm(range(epoch_offset, hparams.epochs),
initial=epoch_offset,
total=hparams.epochs,
desc="Epoch:",
position=1,
unit="epoch"):
tqdm.write("Epoch:{}".format(epoch))
if hparams.distributed_run: # shuffles the train_loader when doing multi-gpu training
train_sampler.set_epoch(epoch)
start_time = time.time()
# start iterating through the epoch
for i, batch in tqdm(enumerate(train_loader),
desc="Iter: ",
smoothing=0,
total=len(train_loader),
position=0,
unit="iter"):
# run external code every iter, allows the run to be adjusted without restarts
if (i == 0 or iteration % param_interval == 0):
try:
with open("run_every_epoch.py") as f:
internal_text = str(f.read())
if len(internal_text) > 0:
#code = compile(internal_text, "run_every_epoch.py", 'exec')
ldict = {
'iteration': iteration,
'checkpoint_iter': checkpoint_iter,
'n_restarts': n_restarts
}
exec(internal_text, globals(), ldict)
else:
print(
"[info] tried to execute 'run_every_epoch.py' but it is empty"
)
except Exception as ex:
print(
f"[warning] 'run_every_epoch.py' FAILED to execute!\nException:\n{ex}"
)
globals().update(ldict)
locals().update(ldict)
if show_live_params:
print(internal_text)
n_restarts = n_restarts_override if (
n_restarts_override is not None) else n_restarts or 0
# Learning Rate Schedule
if custom_lr:
if iteration < warmup_start:
learning_rate = warmup_start_lr
elif iteration < warmup_end:
learning_rate = (iteration - warmup_start) * (
(A_ + C_) - warmup_start_lr
) / (
warmup_end - warmup_start
) + warmup_start_lr # learning rate increases from warmup_start_lr to A_ linearly over (warmup_end-warmup_start) iterations.
else:
if iteration < decay_start:
learning_rate = A_ + C_
else:
iteration_adjusted = iteration - decay_start
learning_rate = (
A_ * (e**(-iteration_adjusted / B_))) + C_
assert learning_rate > -1e-8, "Negative Learning Rate."
if decrease_lr_on_restart:
learning_rate = learning_rate / (2**(n_restarts /
3))
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
# /run external code every epoch, allows the run to be adjusting without restarts/
model.zero_grad()
x, y = model.parse_batch(
batch) # move batch to GPU (async)
y_pred = model(x)
loss_scalars = {
"MelGlow_ls": MelGlow_ls,
"DurGlow_ls": DurGlow_ls,
"VarGlow_ls": VarGlow_ls,
"Sylps_ls": Sylps_ls,
}
loss_dict = criterion(y_pred, y, loss_scalars)
loss = loss_dict['loss']
if hparams.distributed_run:
reduced_loss_dict = {
k: reduce_tensor(v.data, n_gpus).item()
if v is not None else 0.
for k, v in loss_dict.items()
}
else:
reduced_loss_dict = {
k: v.item() if v is not None else 0.
for k, v in loss_dict.items()
}
reduced_loss = reduced_loss_dict['loss']
if hparams.fp16_run:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
if grad_clip_thresh:
if hparams.fp16_run:
grad_norm = torch.nn.utils.clip_grad_norm_(
amp.master_params(optimizer), grad_clip_thresh)
is_overflow = math.isinf(grad_norm) or math.isnan(
grad_norm)
else:
grad_norm = torch.nn.utils.clip_grad_norm_(
model.parameters(), grad_clip_thresh)
else:
grad_norm = 0.0
optimizer.step()
# get current Loss Scale of first optimizer
loss_scale = amp._amp_state.loss_scalers[
0]._loss_scale if hparams.fp16_run else 32768.
# restart if training/model has collapsed
if (iteration > 1e3 and
(reduced_loss > LossExplosionThreshold)) or (
math.isnan(reduced_loss)) or (loss_scale < 1 / 4):
raise LossExplosion(
f"\nLOSS EXPLOSION EXCEPTION ON RANK {rank}: Loss reached {reduced_loss} during iteration {iteration}.\n\n\n"
)
if expavg_loss_dict is None:
expavg_loss_dict = reduced_loss_dict
else:
expavg_loss_dict = {
k: (reduced_loss_dict[k] *
(1 - loss_dict_smoothness)) +
(expavg_loss_dict[k] * loss_dict_smoothness)
for k in expavg_loss_dict.keys()
}
expavg_loss_dict_iters += 1
if expavg_loss_dict_iters > 100:
if best_loss_dict is None:
best_loss_dict = expavg_loss_dict
else:
best_loss_dict = {
k: min(best_loss_dict[k], expavg_loss_dict[k])
for k in best_loss_dict.keys()
}
if rank == 0:
duration = time.time() - start_time
if not is_overflow:
average_loss = rolling_loss.process(reduced_loss)
tqdm.write(
"{} [Train_loss:{:.4f} Avg:{:.4f}] [Grad Norm {:.4f}] "
"[{:.2f}s/it] [{:.3f}s/file] [{:.7f} LR] [{} LS]"
.format(iteration, reduced_loss, average_loss,
grad_norm, duration,
(duration /
(hparams.batch_size * n_gpus)),
learning_rate, round(loss_scale)))
logger.log_training(reduced_loss_dict,
expavg_loss_dict,
best_loss_dict, grad_norm,
learning_rate, duration,
iteration)
else:
tqdm.write("Gradient Overflow, Skipping Step")
start_time = time.time()
if not is_overflow and (
(iteration %
(hparams.iters_per_checkpoint / 1) == 0) or
(os.path.exists(save_file_check_path))):
# save model checkpoint like normal
if rank == 0:
checkpoint_path = os.path.join(
output_directory,
"checkpoint_{}".format(iteration))
save_checkpoint(model, optimizer, learning_rate,
iteration, hparams,
best_validation_loss, average_loss,
best_val_loss_dict, best_loss_dict,
speaker_lookup, checkpoint_path)
if not is_overflow and (
(iteration % int(validation_interval) == 0) or
(os.path.exists(save_file_check_path)) or
(iteration < 1000 and (iteration % 250 == 0))):
if rank == 0 and os.path.exists(save_file_check_path):
os.remove(save_file_check_path)
# perform validation and save "best_model" depending on validation loss
val_loss, best_val_loss_dict = validate(
model, criterion, valset, loss_scalars,
best_val_loss_dict, iteration,
hparams.val_batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run,
rank) #validate (0.8 forcing)
if use_scheduler:
scheduler.step(val_loss)
if (val_loss < best_validation_loss):
best_validation_loss = val_loss
if rank == 0:
checkpoint_path = os.path.join(
output_directory, "best_model")
save_checkpoint(model, optimizer,
learning_rate, iteration,
hparams, best_validation_loss,
average_loss,
best_val_loss_dict,
best_loss_dict, speaker_lookup,
checkpoint_path)
iteration += 1
# end of iteration loop
# end of epoch loop
training = False # exit the While loop
#except Exception as ex: # print Exception and continue from checkpoint. (turns out it takes < 4 seconds to restart like this, f*****g awesome)
except LossExplosion as ex: # print Exception and continue from checkpoint. (turns out it takes < 4 seconds to restart like this, f*****g awesome)
print(ex) # print Loss
checkpoint_path = os.path.join(output_directory, "best_model")
assert os.path.exists(
checkpoint_path
), "best_model checkpoint must exist for automatic restarts"
if hparams.fp16_run:
amp._amp_state.loss_scalers[0]._loss_scale = 32768
# clearing VRAM for load checkpoint
model.zero_grad()
x = y = y_pred = loss = len_loss = loss_z = loss_w = loss_s = loss_att = dur_loss_z = dur_loss_w = dur_loss_s = None
torch.cuda.empty_cache()
model.eval()
model, optimizer, _learning_rate, iteration, best_validation_loss, saved_lookup = load_checkpoint(
checkpoint_path, model, optimizer)
learning_rate = optimizer.param_groups[0]['lr']
epoch_offset = max(0, int(iteration / len(train_loader)))
model.train()
checkpoint_iter = iteration
iteration += 1
n_restarts += 1
def train(
task: str = Task.AgeC, # 수행할 태스크(분류-메인 태스크, 마스크 상태, 연령대, 성별, 회귀-나이)
model_type: str = Config.VanillaEfficientNet, # 불러올 모델명
load_state_dict: str = None, # 학습 이어서 할 경우 저장된 파라미터 경로
train_root: str = Config.TrainS, # 데이터 경로
valid_root: str = Config.ValidS,
transform_type: str = Aug.BaseTransform, # 적용할 transform
epochs: int = Config.Epochs,
batch_size: int = Config.Batch32,
optim_type: str = Config.Adam,
loss_type: str = Loss.CE,
lr: float = Config.LRBase,
lr_scheduler: str = Config.CosineScheduler,
save_path: str = Config.ModelPath,
seed: int = Config.Seed,
):
set_seed(seed)
trainloader = get_dataloader(task, "train", train_root, transform_type, batch_size)
validloader = get_dataloader(
task, "valid", valid_root, transform_type, 1024, shuffle=False, drop_last=False
)
model = load_model(model_type, task, load_state_dict)
model.cuda()
model.train()
optimizer = get_optim(model, optim_type=optim_type, lr=lr)
criterion = get_criterion(loss_type=loss_type, task=task)
if lr_scheduler is not None:
scheduler = get_scheduler(scheduler_type=lr_scheduler, optimizer=optimizer)
best_f1 = 0
if task != Task.Age: # classification(main, ageg, mask, gender)
for epoch in range(epochs):
print(f"Epoch: {epoch}")
# F1, ACC
pred_list = []
true_list = []
# CE Loss
total_loss = 0
num_samples = 0
for idx, (imgs, labels) in tqdm(enumerate(trainloader), desc="Train"):
imgs = imgs.cuda()
labels = labels.cuda()
output = model(imgs)
loss = criterion(output, labels)
_, preds = torch.max(output.data, dim=1)
pred_list.append(preds.data.cpu().numpy())
true_list.append(labels.data.cpu().numpy())
total_loss += loss
num_samples += imgs.size(0)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if lr_scheduler is not None:
scheduler.step()
train_loss = total_loss / num_samples
pred_arr = np.hstack(pred_list)
true_arr = np.hstack(true_list)
train_acc = (true_arr == pred_arr).sum() / len(true_arr)
train_f1 = f1_score(y_true=true_arr, y_pred=pred_arr, average="macro")
if epoch == 0: # logs during just first epoch
wandb.log(
{
f"Ep{epoch:0>2d} Train F1": train_f1,
f"Ep{epoch:0>2d} Train ACC": train_acc,
f"Ep{epoch:0>2d} Train Loss": train_loss,
}
)
if idx != 0 and idx % VALID_CYCLE == 0:
valid_f1, valid_acc, valid_loss = validate(
task, model, validloader, criterion
)
print(
f"[Valid] F1: {valid_f1:.4f} ACC: {valid_acc:.4f} Loss: {valid_loss:.4f}"
)
print(
f"[Train] F1: {train_f1:.4f} ACC: {train_acc:.4f} Loss: {train_loss:.4f}"
)
if epoch == 0:
# logs during one epoch
wandb.log(
{
f"Ep{epoch:0>2d} Valid F1": valid_f1,
f"Ep{epoch:0>2d} Valid ACC": valid_acc,
f"Ep{epoch:0>2d} Valid Loss": valid_loss,
}
)
# logs for one epoch in total
wandb.log(
{
"Train F1": train_f1,
"Valid F1": valid_f1,
"Train ACC": train_acc,
"Valid ACC": valid_acc,
"Train Loss": train_loss,
"Valid Loss": valid_loss,
}
)
if save_path and valid_f1 >= best_f1:
name = f"{model_type}_task({task})ep({epoch:0>2d})f1({valid_f1:.4f})bs({batch_size})loss({valid_loss:.4f})lr({lr})trans({transform_type})optim({optim_type})crit({loss_type})seed({seed}).pth"
best_f1 = valid_f1
torch.save(model.state_dict(), os.path.join(save_path, name))
# regression(age)
else:
for epoch in range(epochs):
print(f"Epoch: {epoch}")
pred_list = []
true_list = []
mse_raw = 0
rmse_raw = 0
num_samples = 0
for idx, (imgs, labels) in tqdm(enumerate(trainloader), desc="Train"):
imgs = imgs.cuda()
# regression(age)
labels_reg = labels.float().cuda()
output = model(imgs)
loss = criterion(output, labels_reg.unsqueeze(1))
mse_raw += loss.item() * len(labels_reg)
rmse_raw += loss.item() * len(labels_reg)
num_samples += len(labels_reg)
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# classification(ageg)
labels_clf = age2ageg(labels.data.numpy())
preds_clf = age2ageg(output.data.cpu().numpy().flatten())
pred_list.append(preds_clf)
true_list.append(labels_clf)
train_rmse = math.sqrt(rmse_raw / num_samples)
train_mse = mse_raw / num_samples
# eval for clf(ageg)
pred_arr = np.hstack(pred_list)
true_arr = np.hstack(true_list)
train_acc = (true_arr == pred_arr).sum() / len(true_arr)
train_f1 = f1_score(y_true=true_arr, y_pred=pred_arr, average="macro")
# logs during one epoch
# wandb.log(
# {
# f"Ep{epoch:0>2d} Train F1": train_f1,
# f"Ep{epoch:0>2d} Train ACC": train_acc,
# f"Ep{epoch:0>2d} Train RMSE": train_rmse,
# f"Ep{epoch:0>2d} Train MSE": train_mse,
# }
# )
if idx != 0 and idx % VALID_CYCLE == 0:
valid_f1, valid_acc, valid_rmse, valid_mse = validate(
task, model, validloader, criterion
)
print(
f"[Valid] F1: {valid_f1:.4f} ACC: {valid_acc:.4f} RMSE: {valid_rmse:.4f} MSE: {valid_mse:.4f}"
)
print(
f"[Train] F1: {train_f1:.4f} ACC: {train_acc:.4f} RMSE: {train_rmse:.4f} MSE: {train_mse:.4f}"
)
# wandb.log(
# {
# "Valid F1": valid_f1,
# "Valid ACC": valid_acc,
# "Valid RMSE": valid_rmse,
# "Valid MSE": valid_mse,
# }
# )
wandb.log(
{
"Train F1": train_f1,
"Valid F1": valid_f1,
"Train ACC": train_acc,
"Valid ACC": valid_acc,
"Train RMSE": train_rmse,
"Valid RMSE": valid_rmse,
"Train MSE": train_mse,
"Valid MSE": valid_mse,
}
)
if save_path:
name = f"{model_type}_task({task})ep({epoch:0>2d})f1({valid_f1:.4f})bs({batch_size})loss({valid_mse:.4f})lr({lr})trans({transform_type})optim({optim_type})crit({loss_type})seed({seed}).pth"
torch.save(model.state_dict(), os.path.join(save_path, name))
audio_norm = audio.unsqueeze(0)
audio_norm = torch.autograd.Variable(audio_norm, requires_grad=False)
melspec = stft.mel_spectrogram(audio_norm)
melspec = melspec.cuda()
return melspec
hparams = create_hparams()
stft = TacotronSTFT(hparams.filter_length, hparams.hop_length,
hparams.win_length, hparams.n_mel_channels,
hparams.sampling_rate, hparams.mel_fmin, hparams.mel_fmax)
# Load Models
checkpoint_path = "pretrained_models/mellotron_libritts.pt"
mellotron = load_model(hparams).cuda().eval()
mellotron.load_state_dict(torch.load(checkpoint_path)['state_dict'])
waveglow_path = '/home/keon/contextron/pretrained_models/waveglow_256channels_universal_v5.pt'
waveglow = torch.load(waveglow_path)['model'].cuda().eval()
denoiser = Denoiser(waveglow).cuda().eval()
# Setup dataloaders
arpabet_dict = cmudict.CMUDict('data/cmu_dictionary')
audio_paths = 'data/refs/refs.txt' # 'data/refs/refs.txt'
dataloader = TextMelLoader(audio_paths, hparams)
datacollate = TextMelCollate(1)
#Load data
file_idx = 0
audio_path, text, sid = dataloader.audiopaths_and_text[file_idx]
def train_cv(
task: str = Task.AgeC, # 수행할 태스크(분류-메인 태스크, 마스크 상태, 연령대, 성별, 회귀-나이)
model_type: str = Config.VanillaEfficientNet, # 불러올 모델명
load_state_dict: str = None, # 학습 이어서 할 경우 저장된 파라미터 경로
train_root: str = Config.TrainS, # 데이터 경로
valid_root: str = Config.ValidS,
transform_type: str = Aug.BaseTransform, # 적용할 transform
age_filter: int=58,
epochs: int = Config.Epochs,
cv: int = 5,
batch_size: int = Config.Batch32,
optim_type: str = Config.Adam,
loss_type: str = Loss.CE,
lr: float = Config.LRBase,
lr_scheduler: str = Config.CosineScheduler,
save_path: str = Config.ModelPath,
seed: int = Config.Seed,
):
if save_path:
kfold_dir = f"kfold_{model_type}_" + get_timestamp()
if kfold_dir not in os.listdir(save_path):
os.mkdir(os.path.join(save_path, kfold_dir))
print(f'Models will be saved in {os.path.join(save_path, kfold_dir)}.')
set_seed(seed)
transform = configure_transform(phase="train", transform_type=transform_type)
trainset = TrainDataset(root=train_root, transform=transform, task=task, age_filter=age_filter, meta_path=Config.Metadata)
validloader = get_dataloader(
task, "valid", valid_root, transform_type, 1024, shuffle=False, drop_last=False
)
kfold = KFold(n_splits=cv, shuffle=True)
for fold_idx, (train_indices, _) in enumerate(
kfold.split(trainset)
): # 앙상블이 목적이므로 test 인덱스는 따로 사용하지 않고, validloader를 통해 성능 검증
if fold_idx == 0 or fold_idx == 1 or fold_idx == 2 or fold_idx == 3: continue
print(f"Train Fold #{fold_idx}")
train_sampler = SubsetRandomSampler(train_indices)
trainloader = DataLoader(
trainset, batch_size=batch_size, sampler=train_sampler, drop_last=True
)
model = load_model(model_type, task, load_state_dict)
model.cuda()
model.train()
optimizer = get_optim(model, optim_type=optim_type, lr=lr)
criterion = get_criterion(loss_type=loss_type, task=task)
if lr_scheduler is not None:
scheduler = get_scheduler(scheduler_type=lr_scheduler, optimizer=optimizer)
best_f1 = 0
if task != Task.Age: # classification(main, ageg, mask, gender)
for epoch in range(epochs):
print(f"Epoch: {epoch}")
# F1, ACC
pred_list = []
true_list = []
# CE Loss
total_loss = 0
num_samples = 0
for idx, (imgs, labels) in tqdm(enumerate(trainloader), desc="Train"):
imgs = imgs.cuda()
labels = labels.cuda()
output = model(imgs)
loss = criterion(output, labels)
_, preds = torch.max(output.data, dim=1)
pred_list.append(preds.data.cpu().numpy())
true_list.append(labels.data.cpu().numpy())
total_loss += loss
num_samples += imgs.size(0)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if lr_scheduler is not None:
scheduler.step()
train_loss = total_loss / num_samples
pred_arr = np.hstack(pred_list)
true_arr = np.hstack(true_list)
train_acc = (true_arr == pred_arr).sum() / len(true_arr)
train_f1 = f1_score(
y_true=true_arr, y_pred=pred_arr, average="macro"
)
if epoch == 0: # logs during just first epoch
wandb.log(
{
f"Fold #{fold_idx} Ep{epoch:0>2d} Train F1": train_f1,
f"Fold #{fold_idx} Ep{epoch:0>2d} Train ACC": train_acc,
f"Fold #{fold_idx} Ep{epoch:0>2d} Train Loss": train_loss,
}
)
if idx != 0 and idx % VALID_CYCLE == 0:
valid_f1, valid_acc, valid_loss = validate(
task, model, validloader, criterion
)
print(
f"[Valid] F1: {valid_f1:.4f} ACC: {valid_acc:.4f} Loss: {valid_loss:.4f}"
)
print(
f"[Train] F1: {train_f1:.4f} ACC: {train_acc:.4f} Loss: {train_loss:.4f}"
)
if epoch == 0:
# logs during one epoch
wandb.log(
{
f"Fold #{fold_idx} Ep{epoch:0>2d} Valid F1": valid_f1,
f"Fold #{fold_idx} Ep{epoch:0>2d} Valid ACC": valid_acc,
f"Fold #{fold_idx} Ep{epoch:0>2d} Valid Loss": valid_loss,
}
)
# logs for one epoch in total
wandb.log(
{
f"Fold #{fold_idx} Train F1": train_f1,
f"Fold #{fold_idx} Valid F1": valid_f1,
f"Fold #{fold_idx} Train ACC": train_acc,
f"Fold #{fold_idx} Valid ACC": valid_acc,
f"Fold #{fold_idx} Train Loss": train_loss,
f"Fold #{fold_idx} Valid Loss": valid_loss,
}
)
if save_path and valid_f1 >= best_f1:
name = f"Fold{fold_idx:0>2d}_{model_type}_task({task})ep({epoch:0>2d})f1({valid_f1:.4f})bs({batch_size})loss({valid_loss:.4f})lr({lr})trans({transform_type})optim({optim_type})crit({loss_type})seed({seed}).pth"
best_f1 = valid_f1
torch.save(
model.state_dict(), os.path.join(save_path, kfold_dir, name)
)
# regression(age)
else:
for epoch in range(epochs):
print(f"Epoch: {epoch}")
pred_list = []
true_list = []
mse_raw = 0
rmse_raw = 0
num_samples = 0
for idx, (imgs, labels) in tqdm(enumerate(trainloader), desc="Train"):
imgs = imgs.cuda()
# regression(age)
labels_reg = labels.float().cuda()
output = model(imgs)
loss = criterion(output, labels_reg.unsqueeze(1))
mse_raw += loss.item() * len(labels_reg)
rmse_raw += loss.item() * len(labels_reg)
num_samples += len(labels_reg)
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
# classification(ageg)
labels_clf = age2ageg(labels.data.numpy())
preds_clf = age2ageg(output.data.cpu().numpy().flatten())
pred_list.append(preds_clf)
true_list.append(labels_clf)
train_rmse = math.sqrt(rmse_raw / num_samples)
train_mse = mse_raw / num_samples
# eval for clf(ageg)
pred_arr = np.hstack(pred_list)
true_arr = np.hstack(true_list)
train_acc = (true_arr == pred_arr).sum() / len(true_arr)
train_f1 = f1_score(
y_true=true_arr, y_pred=pred_arr, average="macro"
)
if idx != 0 and idx % VALID_CYCLE == 0:
valid_f1, valid_acc, valid_rmse, valid_mse = validate(
task, model, validloader, criterion
)
print(
f"[Valid] F1: {valid_f1:.4f} ACC: {valid_acc:.4f} RMSE: {valid_rmse:.4f} MSE: {valid_mse:.4f}"
)
print(
f"[Train] F1: {train_f1:.4f} ACC: {train_acc:.4f} RMSE: {train_rmse:.4f} MSE: {train_mse:.4f}"
)
wandb.log(
{
f"Fold #{fold_idx} Train F1": train_f1,
f"Fold #{fold_idx} Valid F1": valid_f1,
f"Fold #{fold_idx} Train ACC": train_acc,
f"Fold #{fold_idx} Valid ACC": valid_acc,
f"Fold #{fold_idx} Train RMSE": train_rmse,
f"Fold #{fold_idx} Valid RMSE": valid_rmse,
f"Fold #{fold_idx} Train MSE": train_mse,
f"Fold #{fold_idx} Valid MSE": valid_mse,
}
)
if save_path:
name = f"Fold{fold_idx:0>2d}_{model_type}_task({task})ep({epoch:0>2d})f1({valid_f1:.4f})bs({batch_size})loss({valid_mse:.4f})lr({lr})trans({transform_type})optim({optim_type})crit({loss_type})seed({seed}).pth"
torch.save(
model.state_dict(), os.path.join(save_path, kfold_dir, name)
)
model.cpu()
return "\n\n".join("\n".join(p) for p in paragraphs)
if __name__ == "__main__":
bookshelf = Bookshelf((
"/dataset_archive/gutenburg/pgsfcd-032007/data/",
))
book_title = "Edison's Conquest of Mars"
book = find_book(bookshelf, book_title)
words_per_chapter = math.ceil(50000.0 / len(book))
print("Generating {} words per chapter for the {} chapters of '{}'".
format(words_per_chapter, len(book), book_title))
print("Loading Model")
if 'char_model' not in globals():
char_model = model.load_model("language_model")
diversities = (0.4, 0.5, 0.6)
punct = '".!?\'\n'
max_iter = words_per_chapter * 15
generated_chapters = []
for i, chapter in enumerate(book.chapters):
title = chapter['title']
chapter_data = {}
seed = ''
for paragraph in chapter['content']:
seed += paragraph[:model.maxlen]
if len(seed) >= model.maxlen:
break
print("\nSeed: ", seed)
text_generator = model.sample_model2(
char_model,
category = args.category
manualSeed = random.randint(1, 10000)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
torch.cuda.manual_seed_all(manualSeed)
source, target = analysis_dir(category)
SourceTrainDataLoader, SourceTestDataLoader = load_data(source, batch_size)
TargetTrainDataLoader, TargetTestDataLoader = load_data(target, batch_size)
transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Grayscale(num_output_channels=3),
transforms.Pad(padding=2),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
netG = load_model(category).to(device)
optimizerG = optim.Adam(netG.parameters(), lr=lrG)
loss_class = torch.nn.CrossEntropyLoss()
loss_domain = torch.nn.CrossEntropyLoss()
exp = 'check'
trainLogger = open('./%s/%s/train.log' % (exp, category), 'w')
validLogger = open('./%s/%s/valid.log' % (exp, category), 'w')
targetLogger = open('./%s/%s/target.log' % (exp, category), 'w')
train()
trainLogger.close()
validLogger.close()
targetLogger.close()
model_path = config.model_path
result_path = config.result_path
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--input', help='input path')
parser.add_argument('-o', '--output', help='output path')
parser.add_argument('-m',
'--model',
help='model path',
default='CNN_p10_e2000.h5')
args = parser.parse_args()
data_filename = args.input
data_path = os.path.join(data_root, data_filename)
result_filename = args.output if args.output else '{}_detect_by_heatmap.nii'.format(
data_filename.split('/')[-1].split('.')[-2])
result_path = os.path.join(result_path, result_filename)
model_name = args.model
unet_path = os.path.join(model_path, 'unet_pm25_yuzq.hdf5')
clf_path = os.path.join(model_path, model_name)
bet_net = unet(pretrained_weights=unet_path)
model = load_model(clf_path)
mask, mask_roi = detect_file(data_path, model, bet_net)
nib.save(mask, result_path)
nib.save(mask_roi, './mask/roi_by_heatmap.nii')
train_data_dir = FLAGS.data_dir
image_filelist = []
for file in os.listdir(train_data_dir + '/image/'):
if FLAGS.image_filename in file:
image_filelist.append(os.path.join(train_data_dir, 'image', file))
print(image_filelist)
num_labels = 3
num_channels = 1
input_shape = (None, None, None, num_channels)
output_shape = (None, None, None, num_labels)
model = load_model(input_shape=input_shape,
num_labels=num_labels,
base_filter=32,
depth_size=3,
se_res_block=True,
se_ratio=16,
last_relu=False)
print(model)
model.compile(optimizer=Adam(lr=1e-4),
loss=average_dice_coef_loss,
metrics=[average_dice_coef])
df = MyDataFlow(train_data_dir,
FLAGS.image_filename,
FLAGS.label_filename,
shuffle=True)
df = MapDataComponent(df, process.simple_preprocess_img, index=0)
df = MapDataComponent(df, process.sample_z_norm, index=0)
import torch
from model import load_model, move_model_to_GPU
from dataset import create_data_loader
##############
model_num = 0
##############
test_loader = create_data_loader("test")
model = load_model("model_" + str(model_num) + "_epoch_219", isTrain=True) # Optimize et
#model = model.netG
#model.eval()
#print(model.loss_history_G)
model, device = move_model_to_GPU(model)
print("Testing the model...")
for iter, batch in enumerate(test_loader):
batch = batch.to(device)
with torch.no_grad():
model.set_input(batch)
model.forward()
model.save_images(iter, len(batch))
print("Testing done.")
config.gpu_options.allow_growth = True
parser = argparse.ArgumentParser(description='Calculate model adversarial lower bound by PGD')
parser.add_argument('--dataset')
parser.add_argument('--eps', type=float)
parser.add_argument('--model')
parser.add_argument('--attack')
parser.add_argument('--batch_size', type=int, default=128)
parser.add_argument('--cuda_ids', type=int, default=0)
if __name__ == '__main__':
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.cuda_ids)
# load model
model = load_model(args.model)
eps = args.eps
if args.dataset == 'mnist':
mean = normalization['mnist'][0]
std = [normalization['mnist'][1] for _ in mean]
x = input_shape['mnist']
x_op = tf.placeholder(tf.float32, shape=(None, x[0], x[1], x[2],))
elif args.dataset == 'cifar':
mean = normalization['cifar'][0]
std = [normalization['cifar'][1] for _ in mean]
x = input_shape['cifar']
x_op = tf.placeholder(tf.float32, shape=(None, x[0], x[1], x[2],))
train_loader, test_loader = data_loaders(args.dataset, args.batch_size,
shuffle_test=False, norm_mean=mean, norm_std=std)
from selective_search import find_region_proposals
import cv2
import numpy as np
from model import initialize_model, load_model
from dataset import prepare_image
import torch
import matplotlib.pyplot as plt
import torchvision
from tqdm import tqdm
NUM_CLASSES = 21
image_size = (224, 224)
MODEL_PATH = './checkpoints/regression 12-03-2021 22-38-46 epoch-2.pth'
model = initialize_model(NUM_CLASSES)
model, _, _ = load_model(model, MODEL_PATH)
DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
model = model.to(DEVICE)
print("Model Loaded...")
for param in model.parameters():
param.requires_grad = False
torch.no_grad()
class_list = [
'background', 'person', 'bird', 'cat', 'cow', 'dog', 'horse', 'sheep',
'aeroplane', 'bicycle', 'boat', 'bus', 'car', 'motorbike', 'train',
'bottle', 'chair', 'diningtable', 'pottedplant', 'sofa', 'tvmonitor'
]
def draw_boxes(image, boxes):
new_image = image.copy()
for box in boxes:
def train(output_directory, log_directory, checkpoint_path, warm_start, n_gpus,
rank, group_name, hparams):
"""Training and validation logging results to tensorboard and stdout
Params
------
output_directory (string): directory to save checkpoints
log_directory (string) directory to save tensorboard logs
checkpoint_path(string): checkpoint path
n_gpus (int): number of gpus
rank (int): rank of current gpu
hparams (object): comma separated list of "name=value" pairs.
"""
if hparams.distributed_run:
init_distributed(hparams, n_gpus, rank, group_name)
torch.manual_seed(hparams.seed)
# torch.cuda.manual_seed(hparams.seed)
model = load_model(hparams)
learning_rate = hparams.learning_rate
optimizer = torch.optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=hparams.weight_decay)
if hparams.fp16_run:
from apex import amp
model, optimizer = amp.initialize(model, optimizer, opt_level='O2')
if hparams.distributed_run:
model = apply_gradient_allreduce(model)
criterion = Tacotron2Loss()
logger = prepare_directories_and_logger(output_directory, log_directory,
rank)
train_loader, valset, collate_fn, train_sampler = prepare_dataloaders(
hparams)
# Load checkpoint if one exists
iteration = 0
epoch_offset = 0
if checkpoint_path is not None:
if warm_start:
model = warm_start_model(checkpoint_path, model,
hparams.ignore_layers)
else:
model, optimizer, _learning_rate, iteration = load_checkpoint(
checkpoint_path, model, optimizer)
if hparams.use_saved_learning_rate:
learning_rate = _learning_rate
iteration += 1 # next iteration is iteration + 1
epoch_offset = max(0, int(iteration / len(train_loader)))
model.train()
is_overflow = False
# ================ MAIN TRAINNIG LOOP! ===================
for epoch in range(epoch_offset, hparams.epochs):
print("Epoch: {}".format(epoch))
if train_sampler is not None:
train_sampler.set_epoch(epoch)
for i, batch in enumerate(train_loader):
start = time.perf_counter()
if iteration > 0 and iteration % hparams.learning_rate_anneal == 0:
learning_rate = max(hparams.learning_rate_min,
learning_rate * 0.5)
for param_group in optimizer.param_groups:
param_group['lr'] = learning_rate
model.zero_grad()
x, y = model.parse_batch(batch)
y_pred = model(x)
loss = criterion(y_pred, y)
if hparams.distributed_run:
reduced_loss = reduce_tensor(loss.data, n_gpus).item()
else:
reduced_loss = loss.item()
if hparams.fp16_run:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
if hparams.fp16_run:
grad_norm = torch.nn.utils.clip_grad_norm_(
amp.master_params(optimizer), hparams.grad_clip_thresh)
is_overflow = math.isnan(grad_norm)
else:
grad_norm = torch.nn.utils.clip_grad_norm_(
model.parameters(), hparams.grad_clip_thresh)
optimizer.step()
if not is_overflow and rank == 0:
duration = time.perf_counter() - start
print(
"Train loss {} {:.6f} Grad Norm {:.6f} {:.2f}s/it".format(
iteration, reduced_loss, grad_norm, duration))
logger.log_training(reduced_loss, grad_norm, learning_rate,
duration, iteration)
if not is_overflow and (iteration % hparams.iters_per_checkpoint
== 0):
validate(model, criterion, valset, iteration,
hparams.batch_size, n_gpus, collate_fn, logger,
hparams.distributed_run, rank)
if rank == 0:
checkpoint_path = os.path.join(
output_directory, "checkpoint_{}".format(iteration))
save_checkpoint(model, optimizer, learning_rate, iteration,
checkpoint_path)
iteration += 1
from video_interpolation_utilities import *
from model import load_model
import config as config
import glob
import os
import numpy as np
from cv2 import imread,imwrite
import shutil
if __name__ == "__main__":
loaded_model = load_model('./pre-trained-models/model_adaSepConv.json',"./pre-trained-models/model_adaSepConv.h5")
videofile = input("enter path to video file : ")
print("Writing video frames in folder .....")
fps = capture_frames_from_video(videofile)
print("Written all frames successfully ...")
print("Interpolating frames please wait ...")
video_filename = os.path.basename(os.path.splitext(videofile)[0])
print(video_filename)
create_interpolated_frames(glob.glob("./frames_"+ video_filename+"/*"),loaded_model,config.PREDICTION_BATCH,video_filename)
convert_frames_to_video(sorted(glob.glob("./frames_"+ video_filename+"/*")),'./'+video_filename+'.avi',fps*2)
shutil.rmtree("./frames_"+ video_filename)
print("Video generated with double FPS successfully please check current directory")
def remove_disk_cache(obj):
'''Recusively removes disk caches from the object.'''
for name, val in obj.__dict__.items():
if isinstance(val, features.DiskCachedFeatures):
obj.__dict__[name] = (
features.MemCachedFeatures.create_shared_cache(
val.feature_generator))
else:
try:
remove_disk_cache(val)
except AttributeError:
pass
return obj
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--output', '-o', default='neon.model',
help='File to output the model definition')
parser.add_option('--input', '-i', default='neon.model',
help='File to input the model definition')
options, args = parser.parse_args()
model.save_model(
remove_disk_cache(model.load_model(options.input)),
options.output)
"""
# API Dependencies
import pickle
import json
import numpy as np
from model import load_model, make_prediction
from flask import Flask, request, jsonify
# Application definition
app = Flask(__name__)
# Load our model into memory.
# Please update this path to reflect your own trained model.
static_model = load_model(path_to_model='assets/trained-models/xgbmodel.pkl')
print('-' * 40)
print('Model succesfully loaded')
print('-' * 40)
# Define the API's interface.
# Here the 'model_prediction()' function will be called when a POST request
# is sent to our interface located at:
# http:{Host-machine-ip-address}:5000/api_v0.1
@app.route('/api_v0.1', methods=['POST'])
def model_prediction():
# We retrieve the data payload of the POST request
data = request.get_json(force=True)
# We then preprocess our data, and use our pretrained model to make a
""" Vietnamese Accent Predictor demo """
import io
import os
import hug
import model
MODEL_DIR = os.environ.get('MODELS_DIR', 'models')
MODEL_VERSION = os.environ.get('MODEL_VERSION', 'v2')
the_model = model.load_model(os.path.join(MODEL_DIR, MODEL_VERSION))
with io.open('static/index.html', encoding='utf-8') as f:
index_page = f.read()
@hug.request_middleware()
def enable_cors_all(request, response):
response.set_header('Access-Control-Allow-Origin', '*')
@hug.get('/', output=hug.output_format.html)
def index():
""" Demo homepage """
return index_page
@hug.get(examples='text=co%20gai%20den%20tu%20hom%20qua')
def accented(text: hug.types.text, hug_timer=3):
""" Add accent to given plain text """
return {
"""
# API Dependencies
import pickle
import json
import numpy as np
from model import load_model, make_prediction
from flask import Flask, request, jsonify
# Application definition
app = Flask(__name__)
# Load our model into memory.
# Please update this path to reflect your own trained model.
static_model = load_model(path_to_model='assets/trained-models/rfmodel_2.pkl')
print('-' * 40)
print('Model succesfully loaded')
print('-' * 40)
# Define the API's interface.
# Here the 'model_prediction()' function will be called when a POST request
# is sent to our interface located at:
# http:{Host-machine-ip-address}:5000/api_v0.1
@app.route('/api_v0.1', methods=['POST'])
def model_prediction():
# We retrieve the data payload of the POST request
data = request.get_json(force=True)
# We then preprocess our data, and use our pretrained model to make a
# prediction.
def call_method(choice):
#global variables
global data, data10to14, data15to16, analysis_data, community_area, primary_type, data_enriched_dist, X, primaryType_onehot, test_data_X, primaryType_onehot_test
global list_of_lr_models, list_of_nn_models, list_of_knn_models, list_of_dt_models, list_of_nb_models
global data10to16, data15to16_enriched_dist
if (choice == 1):
#Reads in the data
data = dec.read_data(dec.query, dec.conn)
elif (choice == 2):
#Runs preliminary analysis and totals
dec.time_series_graph_month(data)
dec.time_series_graph_year(data)
dec.table_primary_type_volume(data)
dec.table_primary_type_volume05to09(data)
dec.table_primary_type_volume10to14(data)
elif (choice == 3):
#Cuts down the dataset to just the years we are interested
data10to14, community_area, primary_type = dec.cut_down_data(data)
elif (choice == 4):
#production of charts and analysis
analysis_data = dec.get_analysis(data10to14)
dec.chart_data(analysis_data, community_area)
print(data10to14.shape)
dec.time_series_community_area_graph_year(data10to14, community_area)
dec.chart_primary_type(data10to14)
dec.time_series_year_primary_type(data10to14)
dec.rolling_yearly_primary_type(data, community_area, primary_type)
dec.calculate_percentage_arrests(data10to14, community_area)
elif (choice == 5):
#production of heat maps
dec.heatmap_primary_type_location_desc(data10to14)
dec.heatmap_year_community_area(data10to14)
dec.heatmap_month_community_area(data10to14)
dec.heatmap_weekday_community_area(data10to14)
dec.heatmap_hour_community_area(data10to14)
dec.heatmap_hour_primary_type(data10to14)
dec.heatmap_month_primary_type(data10to14)
dec.heatmap_weekday_primary_type(data10to14)
elif (choice == 6):
#Enrich the geographic data where the longitude / latitude values are null
data_enriched = dec.geographical_data_analysis(data10to14, data10to14)
data_enriched.shape
data_enriched_dist = dec.calculate_distance_from_mean(data_enriched)
data_enriched_dist.shape
elif (choice == 7):
#create the model data pre processing
model_data = data_enriched_dist
model_data = model_data.dropna() #drop the 11 rows containing nulls
model_data['District'] = model_data.District.astype(float)
model_data['Ward'] = model_data.Ward.astype(float)
model_data['Beat'] = model_data.Beat.astype(float)
communityArea_onehot, month_onehot, weekday_onehot, domestic_onehot, distance_band_onehot, primaryType_onehot, arrest_onehot = m.generate_one_hot_data(
model_data)
X = m.append_one_hot_datasets(model_data, communityArea_onehot,
month_onehot, weekday_onehot,
distance_band_onehot, arrest_onehot)
elif (choice == 8):
#build logisitic regression models
type_model = 'logisitic_regression_model'
list_of_lr_models = m.primary_type_model(X, primary_type,
primaryType_onehot,
type_model)
m.save_model(list_of_lr_models, type_model)
m.save_test_results(type_model, list_of_lr_models)
print(list_of_lr_models)
elif (choice == 9):
#build neural network models
type_model = 'neural_network_model'
list_of_nn_models = m.primary_type_model(X, primary_type,
primaryType_onehot,
type_model)
m.save_model(list_of_nn_models, type_model)
m.save_test_results(type_model, list_of_nn_models)
print(list_of_nn_models)
elif (choice == 10):
#build K Nearest Neighbour models
print('build started', datetime.datetime.now())
type_model = 'knn_classifier_model'
list_of_knn_models = m.primary_type_model(X, primary_type,
primaryType_onehot,
type_model)
m.save_model(list_of_knn_models, type_model)
m.save_test_results(type_model, list_of_knn_models)
print(list_of_knn_models)
print('build finished', datetime.datetime.now())
elif (choice == 11):
#Build Decision Tree models
type_model = 'decision_tree_model'
list_of_dt_models = m.primary_type_model(X, primary_type,
primaryType_onehot,
type_model)
m.save_model(list_of_dt_models, type_model)
m.save_test_results(type_model, list_of_dt_models)
print(list_of_dt_models)
elif (choice == 12):
#Build naive bayes models
type_model = 'naive_baye_model'
list_of_nb_models = m.primary_type_model(X, primary_type,
primaryType_onehot,
type_model)
m.save_model(list_of_nb_models, type_model)
m.save_test_results(type_model, list_of_nb_models)
print(list_of_nb_models)
elif (choice == 13):
#Extract data for 2015/16
print('Step 1: Get Test Data 2015 and 2016')
data15to16 = m.fetch_new_data(m.sql, m.conn)
print('Data read in ', data15to16.shape)
data15to16 = m.cut_down_test_data(data15to16, community_area,
primary_type)
print('cut down the dataset', data15to16.shape)
data15to16_enriched = dec.geographical_data_analysis(
data15to16, data10to14)
print(data15to16_enriched.shape)
print('Add the calculated distances to the dataset')
data15to16_enriched_dist = dec.calculate_distance_from_mean(
data15to16_enriched)
print('Create the one hot datasets')
communityArea_onehot_test, month_onehot_test, weekday_onehot_test, domestic_onehot_test, distance_band_onehot_test, primaryType_onehot_test, arrest_onehot_test = m.generate_one_hot_data(
data15to16_enriched_dist)
test_data_X = m.append_one_hot_datasets(data15to16_enriched_dist,
communityArea_onehot_test,
month_onehot_test,
weekday_onehot_test,
distance_band_onehot_test,
arrest_onehot_test)
print(len(test_data_X))
elif (choice == 14):
#Test Logistic Regression model
print('14 running')
type_model = 'logisitic_regression_model'
model_score = m.test_new_data(list_of_lr_models, test_data_X,
primary_type, primaryType_onehot_test)
m.save_results(type_model, model_score)
elif (choice == 15):
#Test KNN model
print('15 running')
print('Read data started', datetime.datetime.now())
type_model = 'knn_classifier_model'
model_score = m.test_new_data(list_of_knn_models, test_data_X,
primary_type, primaryType_onehot_test)
m.save_results(type_model, model_score)
print('Finished ', datetime.datetime.now())
elif (choice == 16):
#Test neural networks
print('16 running')
type_model = 'neural_network_model'
model_score = m.test_new_data(list_of_nn_models, test_data_X,
primary_type, primaryType_onehot_test)
m.save_results(type_model, model_score)
elif (choice == 17):
#Test Decision Tree
type_model = 'decision_tree_model'
model_score = m.test_new_data(list_of_dt_models, test_data_X,
primary_type, primaryType_onehot_test)
m.save_results(type_model, model_score)
elif (choice == 18):
#Test naive baye model
print('you chose 18')
type_model = 'naive_baye_model'
model_score = m.test_new_data(list_of_nb_models, test_data_X,
primary_type, primaryType_onehot_test)
m.save_results(type_model, model_score)
elif (choice == 19):
#load models from directory
print('load models')
list_of_lr_models = []
type_model = 'logisitic_regression_model'
list_of_lr_models = m.load_model(primary_type, type_model)
list_of_nn_models = []
type_model = 'neural_network_model'
list_of_nn_models = m.load_model(primary_type, type_model)
list_of_knn_models = []
type_model = 'knn_classifier_model'
list_of_knn_models = m.load_model(primary_type, type_model)
list_of_dt_models = []
type_model = 'decision_tree_model'
list_of_dt_models = m.load_model(primary_type, type_model)
list_of_nb_models = []
type_model = 'naive_baye_model'
list_of_nb_models = m.load_model(primary_type, type_model)
elif (choice == 0):
#Read in data for 10 to 16
data10to16 = m.pre_processing(m.sql_pre_proc, dec.conn, primary_type,
community_area)
#If you are interested in seeing the correlation matrices
m.feature_selection(data10to16)
elif (choice == 20):
exit()
else:
exit()
line_list_map = [mapping_rev[x] for x in line_list]
out_1.append(line_list_map)
out_1 = np.asarray(out_1)
out1_onehot = np.eye(nc, dtype='uint8')[out_1]
out1_onehot = np.rollaxis(out1_onehot, 2, 0)
out1_onehot = out1_onehot[None, :, :]
data_1 = torch.FloatTensor(out1_onehot)
z_1, _, _ = model.encode(data_1)
return z_1
path = 'vae_ng_64_final.pth'
model = load_model(nc, nz)
def compute_density(z):
z_decoded = model.decode(z)
level = z_decoded.data.cpu().numpy()
level = np.argmax(level, axis=1)
total = 0
for line in level[0]:
total += len(line[line == 0]) # X
total += len(line[line == 1]) # S
total += len(line[line == 3]) # Q
total += len(line[line == 4]) # ?
total += len(line[line == 11]) # T
total += len(line[line == 12]) # M
total += len(line[line == 14]) # #
import model
import time
from random import random
from math import sin, cos, pi
mod = model.load_model('../openpixelcontrol/layouts/my_sphere.json')
totalLife = 50 # how long to keep the dots there
numParticles = 10
zoom = 0.998
intensity = -1.2
backgroundHue = random()
# Start out with just a background
particles = []
def newBloomTimer():
return random() * 100 # how often and fast new things show
def randomPoint():
#A random point somewhere relevant on our model
return [
4 * (random() - 0.5),
1 * (random() - 0.5),
4 * (random() - 0.5)
]
# Create other nascent particles that 'bloom' once a timer runs out
for i in range(numParticles):
particles.append({
def main(_run, _log):
args = argparse.Namespace(**_run.config)
args = post_config_hook(args, _run)
args.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
args.n_gpu = torch.cuda.device_count()
root = "./datasets"
train_sampler = None
if args.dataset == "STL10":
train_dataset = torchvision.datasets.STL10(
root,
split="unlabeled",
download=True,
transform=TransformsSimCLR(size=96))
elif args.dataset == "CIFAR10":
train_dataset = torchvision.datasets.CIFAR10(
root, download=True, transform=TransformsSimCLR(size=32))
else:
raise NotImplementedError
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
drop_last=True,
num_workers=args.workers,
sampler=train_sampler,
)
model, optimizer, scheduler = load_model(args, train_loader)
print(f"Using {args.n_gpu}'s")
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
model = convert_model(model)
model = model.to(args.device)
print(model)
tb_dir = os.path.join(args.out_dir, _run.experiment_info["name"])
os.makedirs(tb_dir)
writer = SummaryWriter(log_dir=tb_dir)
criterion = NT_Xent(args.batch_size, args.temperature, args.device)
args.global_step = 0
args.current_epoch = 0
for epoch in range(args.start_epoch, args.epochs):
lr = optimizer.param_groups[0]['lr']
loss_epoch = train(args, train_loader, model, criterion, optimizer,
writer)
if scheduler:
scheduler.step()
if epoch % 10 == 0:
save_model(args, model, optimizer)
writer.add_scalar("Loss/train", loss_epoch / len(train_loader), epoch)
writer.add_scalar("Misc/learning_rate", lr, epoch)
print(
f"Epoch [{epoch}/{args.epochs}]\t Loss: {loss_epoch / len(train_loader)}\t lr: {round(lr, 5)}"
)
args.current_epoch += 1
## end training
save_model(args, model, optimizer)
for c in str(mod):
if c == '{' or c == '[':
indent += 2
outString += '%s\n%s' % (c,' '*indent)
brackets.append(c)
continue
elif c == '}' or c == ']':
indent -= 2
outString += '\n%s' % (' '*indent)
brackets.pop()
elif c == '(':
brackets.append(c)
elif c == ')':
brackets.pop()
elif c == ',':
if brackets[-1] <> '(':
outString += '\n%s' % (' '*indent)
continue
outString += c
print outString
if __name__ == '__main__':
parser = OptionParser(usage=USAGE)
options, args = parser.parse_args()
mod = model.load_model(args[0])
PrettyPrintModel(mod)
