def train_loop(model_in, train_dl, epochs):
optimizer = optim.Adam(model_in.parameters(), lr=0.001, weight_decay=5e-5)
loss_function = nn.BCELoss()
model_in.train()
for i in range(epochs):
for i_batch, sample_batched in enumerate(tqdm(train_dl)):
batch_X = sample_batched['mri'].to(device)
batch_Xb = sample_batched['clin_t'].to(device)
batch_y = sample_batched['label'].to(device)
model_in.zero_grad()
outputs = model_in((batch_X, batch_Xb))
loss = loss_function(outputs, batch_y)
loss.backward()
optimizer.step()
tqdm.write("Epoch: {}/{}, train loss: {}".format(
i, epochs, round(loss.item(), 5)))
def shardify_openwebtext(input_dir: str,
output_dir: str,
n_processes: int,
n_shards: int = 20):
input_dir = Path(input_dir)
assert input_dir.exists()
output_dir = Path(output_dir)
output_dir.mkdir()
subset_dirs = [
subset_dir for subset_dir in input_dir.iterdir()
if subset_dir.is_dir()
]
with mp.Pool(processes=n_processes) as pool:
# Get list of sorted files in OpenWebText
text_files = sorted(
list(chain.from_iterable(pool.map(text_files_in_dir,
subset_dirs))))
# Split list of files into shards
shard_files = np.array_split(text_files, n_shards)
# Save shards and associated filenames
for i, split in enumerate(tqdm(shard_files)):
tqdm.write("Loading text in shard...")
shard = pool.map(read_text, split)
tqdm.write("Saving shard...")
shard_name = f'owtc{i:02d}'
dump(shard, output_dir / f'{shard_name}.joblib')
filenames = map(lambda f: f.stem, split)
with open(output_dir / f'{shard_name}_filenames.txt', 'w') as f:
print(*filenames, file=f, sep='\n')
def _validate(self, epoch, hide_progress):
assert self.dl_valid is not None
self.model.eval()
with torch.no_grad():
for img_batch, mask_batch in tqdm(self.dl_valid,
desc="Validating",
disable=hide_progress,
leave=False,
position=0):
img_batch, mask_batch = img_batch.to(
self.device), mask_batch.to(self.device)
model_output = self.model(img_batch)
loss = self.criterion(model_output, mask_batch)
self.recorder.update_record_on_batch_end(
epoch,
loss.item(),
mask_batch,
model_output.squeeze(),
img_batch.size(0),
self.num_validation_samples,
training=False)
self.recorder.finalize_record_on_epoch_end(training=False)
tqdm.write(self.recorder.get_latest_epoch_message(training=False))
def _train_one_epoch(self, epoch, scheduler, hide_progress):
self.model.train()
for img_batch, mask_batch in tqdm(self.dl_train,
desc=f"Epoch {epoch}",
leave=False,
disable=hide_progress,
position=0):
img_batch, mask_batch = img_batch.to(self.device), mask_batch.to(
self.device)
self.optimizer.zero_grad()
model_output = self.model(img_batch)
loss = self.criterion(model_output, mask_batch)
with torch.no_grad():
self.recorder.update_record_on_batch_end(
epoch, loss.item(), mask_batch, model_output.squeeze(),
img_batch.size(0), self.num_train_samples)
loss.backward()
self.optimizer.step()
scheduler.step()
with torch.no_grad():
self.recorder.finalize_record_on_epoch_end()
tqdm.write(self.recorder.get_latest_epoch_message(training=True))
def oracc_download(p):
"""Downloads ZIP with JSON files from
ORACC server. Parameter is a list
with ORACC project names,
return is the same list of names,
minus doublets and non-existing
projects"""
CHUNK = 16 * 1024
p = list(set(p)) #remove duplicates
projects = p.copy()
for project in p:
proj = project.replace('/', '-')
url = "http://build-oracc.museum.upenn.edu/json/" + proj + ".zip"
file = 'jsonzip/' + proj + '.zip'
with requests.get(url, stream=True) as r:
if r.status_code == 200:
tqdm.write("Saving " + url + " as " + file)
with open(file, 'wb') as f:
for c in tqdm(r.iter_content(chunk_size=CHUNK),
desc=project):
f.write(c)
else:
tqdm.write(url + " does not exist.")
projects.remove(project)
return projects
def run(self):
with self.device:
self._init_vars()
self._power_method()
self.L_init = []
self.R_init = []
for j in range(self.J):
self.L_init.append(sp.to_device(self.L[j]))
self.R_init.append(sp.to_device(self.R[j]))
done = False
while not done:
try:
self.L = []
self.R = []
for j in range(self.J):
self.L.append(sp.to_device(self.L_init[j],
self.device))
self.R.append(sp.to_device(self.R_init[j],
self.device))
self._sgd()
done = True
except OverflowError:
self.alpha *= self.beta
if self.show_pbar:
tqdm.write('\nReconstruction diverged. '
'Scaling step-size by {}.'.format(
self.beta))
if self.comm is None or self.comm.rank == 0:
return MultiScaleLowRankImage(
(self.T, ) + self.img_shape,
[sp.to_device(L_j, sp.cpu_device) for L_j in self.L],
[sp.to_device(R_j, sp.cpu_device) for R_j in self.R])
def download_kanji(self, kanji: str, force=False) -> bool:
path = self.out_dir / (str(ord(kanji)) + ".html")
if not force and path.exists():
tqdm.write("Skipping existing kanji {}".format(kanji))
return False
self._download(self._build_url(kanji), path)
return True
def GetLungSegData(initial_dir):
# First, let's get all the subject directories. We'll do this by proceeding
# through the directory structure and grabbing the ones we want.
# We'll use the package glob for finding directories
# The input to this function was the LCTSC directory
# Now we'll get all the subject directories using glob
subj_dirs = glob.glob(os.path.join(initial_dir, 'LCTSC*'))
# and feed those directories into another function that loads
# the dicoms and masks for each
data = [GetLCTSCdata(d) for d in tqdm(subj_dirs, desc='Loading data:')]
# get all images together as inputs
inputs = np.concatenate([d[0] for d in data])
# get all masks together as targets
targets = np.concatenate([d[1] for d in data])
# add a singleton dimension to the input and target arrays
inputs = inputs[..., np.newaxis]
targets = targets[..., np.newaxis]
# Get the total number of slices
num_slices = inputs.shape[0]
# Find the cutoff- set to 90% train and 10% validation
split_ind = np.int(.1 * num_slices)
# split into training and validation sets using the cutoff
x_val = inputs[:split_ind]
y_val = targets[:split_ind]
x_train = inputs[split_ind:]
y_train = targets[split_ind:]
tqdm.write('Data loaded')
return x_train, y_train, x_val, y_val
def get_grid_panoids(grid, closest=False, proxies=None, max_retry=3):
"""Get the closest panoramas (ids) for the GPS coordinates list.
If the 'closest' boolean parameter is set to true, only the closest panorama
will be gotten (at all the available dates)
"""
def _gen_result(result):
for r in result:
yield r
pan_urls = []
for lat, lon in grid:
pan_urls.append(get_panoids_url(lat, lon))
pan_urls = np.array(pan_urls)
# Try to get the panorama's data
responses = np.zeros(len(pan_urls), dtype=bool)
result = []
n_retry = 0
while any(responses == False) and n_retry < max_retry:
if n_retry > 0:
tqdm.write("[get_grid_panoids] Connection error. Trying again in 2 seconds.")
time.sleep(2)
idxs = (responses == False).nonzero()[0]
rs = (grequests.get(p_url, stream=True) for p_url in pan_urls[idxs])
res = grequests.map(rs)
for i, res_i in zip(idxs, res):
if res_i is not None:
pans = postprocess_panoids(res_i.text, closest=closest, proxies=proxies)
result.extend(pans)
# result.append((grid[i], pans))
# yield (grid[i], pans)
responses[i] = True
n_retry += 1
return result
def _cvat_export_dataset_cli(
cvat_params, task_id, dataset_format, position, unzip=True
):
"""Download a dataset from CVAT (with progress bar)"""
output = Path(f"{dataset_format}_{task_id}")
output_zip = output.with_suffix(".zip")
if output.exists():
print(f"{output} already exists, skipping download")
return
with tqdm(
desc=f"Exporting dataset for task {task_id}",
position=position,
leave=False,
) as pbar:
try:
cvat_export_dataset(
cvat_params, task_id, output_zip, dataset_format, progress=pbar
)
except requests.exceptions.HTTPError as exc:
tqdm.write("Failed exporting dataset {}: {}".format(task_id, exc))
if unzip:
tqdm.write(f"Unpacking {output_zip}")
unzip_dataset(output_zip)
def write(self, buf):
# Set default streams back
# They are required for correct tqdm.write work
# See tqdm.tqdm.external_write_mode()
with self._std_streams():
for line in buf.rstrip().splitlines():
tqdm.write(line.rstrip(), self._real_stream)
def train(ae, dataloader, criterion, optimizer, use_gpu=True, epochs=5):
t_begin = time.time()
if use_gpu:
ae.cuda()
criterion.cuda()
losses = []
for epoch in tqdm(range(epochs), desc='Epoch'):
for step, example in enumerate(tqdm(dataloader, desc='Batch')):
if use_gpu:
example = example.cuda()
optimizer.zero_grad()
prediction = ae(example)
loss = criterion(example, prediction)
loss.backward()
optimizer.step()
losses.append(float(loss))
if (step % 300) == 0:
tqdm.write('Loss: {}\n'.format(loss))
t_end = time.time()
timestamp = datetime.datetime.fromtimestamp(t_end).strftime('%Y-%m-%d-%H-%M-%S')
time_training = t_end - t_begin
return losses, timestamp, time_training
def main():
device='cuda'
batch_size = 256
normalize = {
'mean': [0.485, 0.456, 0.406],
'std': [0.229, 0.224, 0.225]
}
lr = 1e-1
epochs = 200
scaler = torch.cuda.amp.GradScaler()
# transform = common_train((224, 224))
trainset = ImageNet(os.environ['DATAROOT'], transform=common_train((224, 224)), train=True, subset=50)
testset = ImageNet(os.environ['DATAROOT'], transform=common_test((224, 224)), train=False, subset=50)
train_loader = DataLoader(trainset, batch_size=batch_size, shuffle=True, pin_memory=False, num_workers=12)
test_loader = DataLoader(testset, batch_size=batch_size, shuffle=True, pin_memory=False, num_workers=12)
model = resnet18(**normalize, class_num=50).to(device)
model = nn.DataParallel(model, device_ids=list(range(torch.cuda.device_count())))
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-4, nesterov=True)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs, 1e-4, -1)
# scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[30, 60, 90], gamma=0.1, last_epoch=-1)
runner = Runner(model, train_loader, test_loader, criterion, optimizer, scheduler, scaler, epochs, 10)
tqdm.write("Start training with Resnet18.")
runner.train()
def write(self, msg: str) -> int:
try:
tqdm.write(msg, end='')
except BrokenPipeError:
sys.stderr.write(msg)
return 0
return len(msg)
def download_tiles(tiles, directory, disp=False):
"""
Downloads all the tiles in a Google Stree View panorama into a directory.
Params:
tiles - the list of tiles. This is generated by get_tiles_info(panoid).
directory - the directory to dump the tiles to.
"""
for i, (x, y, fname, url) in enumerate(tiles):
if disp and i % 20 == 0:
print("Image %d / %d" % (i, len(tiles)))
# Try to download the image file
while True:
try:
response = requests.get(url, stream=True)
break
except requests.ConnectionError:
tqdm.write("Connection error. Trying again in 2 seconds.")
time.sleep(2)
with open(directory + '/' + fname, 'wb') as out_file:
shutil.copyfileobj(response.raw, out_file)
del response
def main():
# Distributed setting.
torch.distributed.init_process_group(backend='nccl', init_method='env://')
device_id = get_device_id()
torch.cuda.set_device(device_id)
device = f'cuda:{device_id}'
# Automatic mixed precision.
scaler = torch.cuda.amp.GradScaler()
batch_size = 128
normalize = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
lr = 1e-1
epochs = 200
trainset = ImageNet(os.environ['DATAROOT'],
transform=common_train((224, 224)),
train=True,
subset=50)
testset = ImageNet(os.environ['DATAROOT'],
transform=common_test((224, 224)),
train=False,
subset=50)
# Use distributed sampler to map data parts to different CUDA devices.
trainsampler = torch.utils.data.distributed.DistributedSampler(trainset)
testsampler = torch.utils.data.distributed.DistributedSampler(testset)
train_loader = DataLoader(trainset,
batch_size=batch_size,
sampler=trainsampler,
pin_memory=False,
num_workers=12)
test_loader = DataLoader(testset,
batch_size=batch_size,
sampler=testsampler,
pin_memory=False,
num_workers=12)
model = resnet18(**normalize, class_num=50).to(device)
# Distributed: convert the BN layers of the model into sync-BN layers.
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
# Distributed: create DDP model.
model = nn.parallel.DistributedDataParallel(model,
device_ids=[device_id],
output_device=device_id)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=1e-4,
nesterov=True)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs, 1e-4,
-1)
# Use DistRunner to run DDP train and evaluation.
runner = DistRunner(model, train_loader, test_loader, criterion, optimizer,
scheduler, scaler, epochs, 10)
tqdm.write("Start training with Resnet18.")
runner.train()
def parsedNames(list, verbose):
"""Used to parse names from a document of names."""
names = []
if verbose: tqdm.write(f"Parsing names in file {os.path.basename(list)}")
with open(list, "r", encoding="utf-8") as nameList:
for line in nameList:
names.append(line.rstrip())
return names
def __call__(self, epoch, train_loss, val_loss):
log_string = (f"Epoch [{epoch}/{self.num_epochs}], "
f"Train Loss: {train_loss:.4f}, "
f"Val Loss: {val_loss:.4f} ")
if epoch % self.log_interval == 0:
tqdm.write(log_string)
self.log.append(log_string)
if self.best is None or val_loss < self.best:
self.best = val_loss
def emit(self, record):
try:
msg = self.format(record)
self.flush()
tqdm.write(msg, file=sys.stderr)
except (KeyboardInterrupt, SystemExit) as e:
raise e
except Exception:
self.handleError(record)
def feature_extract(eval_set, model, device, opt, config):
if not exists(opt.output_features_dir):
makedirs(opt.output_features_dir)
output_local_features_prefix = join(opt.output_features_dir, 'patchfeats')
output_global_features_filename = join(opt.output_features_dir,
'globalfeats.npy')
pool_size = int(config['global_params']['num_pcs'])
test_data_loader = DataLoader(
dataset=eval_set,
num_workers=int(config['global_params']['threads']),
batch_size=int(config['feature_extract']['cacheBatchSize']),
shuffle=False,
pin_memory=(not opt.nocuda))
model.eval()
with torch.no_grad():
tqdm.write('====> Extracting Features')
db_feat = np.empty((len(eval_set), pool_size), dtype=np.float32)
for iteration, (input_data, indices) in \
enumerate(tqdm(test_data_loader, position=1, leave=False, desc='Test Iter'.rjust(15)), 1):
indices_np = indices.detach().numpy()
input_data = input_data.to(device)
image_encoding = model.encoder(input_data)
if config['global_params']['pooling'].lower() == 'patchnetvlad':
vlad_local, vlad_global = model.pool(image_encoding)
vlad_global_pca = get_pca_encoding(model, vlad_global)
db_feat[indices_np, :] = vlad_global_pca.detach().cpu().numpy()
for this_iter, this_local in enumerate(vlad_local):
this_patch_size = model.pool.patch_sizes[this_iter]
db_feat_patches = np.empty(
(this_local.size(0), pool_size, this_local.size(2)),
dtype=np.float32)
grid = np.indices((1, this_local.size(0)))
this_local_pca = get_pca_encoding(model, this_local.permute(2, 0, 1).reshape(-1, this_local.size(1))).\
reshape(this_local.size(2), this_local.size(0), pool_size).permute(1, 2, 0)
db_feat_patches[
grid, :, :] = this_local_pca.detach().cpu().numpy()
for i, val in enumerate(indices_np):
image_name = os.path.splitext(
os.path.basename(eval_set.images[val]))[0]
filename = output_local_features_prefix + '_' + 'psize{}_'.format(
this_patch_size) + image_name + '.npy'
np.save(filename, db_feat_patches[i, :, :])
else:
vlad_global = model.pool(image_encoding)
vlad_global_pca = get_pca_encoding(model, vlad_global)
db_feat[indices_np, :] = vlad_global_pca.detach().cpu().numpy()
np.save(output_global_features_filename, db_feat)
def emit(self, record: Any) -> None:
try:
msg = self.format(record)
tqdm.write(msg)
self.flush()
except (KeyboardInterrupt, SystemExit):
raise
except Exception:
self.handleError(record)
def emit(self, record: logging.LogRecord):
if record.levelno < self.level:
return
try:
msg = self.format(record)
tqdm.write(msg, file=sys.stderr)
self.flush()
except Exception: # noqa
self.handleError(record)
def train(self, train_set, dev_set):
self.iterations, self.nb_tr_steps, self.tr_loss = 0, 0, 0
self.best_valid_metric, self.unimproved_iters = 0, 0
self.early_stop = False
if self.args.gradient_accumulation_steps < 1:
raise ValueError(
"Invalid gradient_accumulation_steps parameter: {}, should be >= 1"
.format(self.args.gradient_accumulation_steps))
self.args.batch_size = (self.args.batch_size //
self.args.gradient_accumulation_steps)
self.init_optimizer()
train_dataset = convert_df_to_ids(train_set, self.word2id,
self.args.max_seq_length)
dev_dataset = convert_df_to_ids(dev_set, self.word2id,
self.args.max_seq_length)
train_dataloader = DataLoader(
train_dataset,
sampler=RandomSampler(train_dataset),
batch_size=self.args.batch_size,
)
dev_dataloader = DataLoader(
dev_dataset,
sampler=SequentialSampler(dev_dataset),
batch_size=self.args.batch_size,
)
for epoch in tqdm(range(int(self.args.epochs))):
self.tr_loss = self.train_an_epoch(train_dataloader)[0]
tqdm.write(f"[Epoch {epoch}] loss: {self.tr_loss}".format(
epoch, self.best_valid_metric))
self.tr_loss = 0
eval_result = self.eval(dev_dataloader)
# Update validation results
if eval_result[self.args.valid_metric] > self.best_valid_metric:
self.unimproved_iters = 0
self.best_valid_metric = eval_result[self.args.valid_metric]
print_dict_as_table(
eval_result,
tag=f"[Epoch {epoch}]performance on validation set",
columns=["metrics", "values"],
)
ensureDir(self.args.model_save_dir)
self.save_pretrained(self.args.model_save_dir)
else:
self.unimproved_iters += 1
if self.unimproved_iters >= self.args.patience:
self.early_stop = True
tqdm.write(
"Early Stopping. Epoch: {}, best_valid_metric ({}): {}"
.format(epoch, self.args.valid_metric,
self.best_valid_metric))
break
def train(
self: [AnimeHeadsTrainer, BirdsTrainer],
n_step,
step_per_epoch=500, # print loss each step_per_epoch
saveck_every=None,
ck_path: str = None,
):
assert n_step % step_per_epoch == 0, f'n_step: {n_step} % step_per_epoch: {step_per_epoch} should be 0'
losses = []
total_start_t = time.time()
log_start_t = time.time()
dl = InfiniteDl(self.dls.train)
pb = tqdm(range(1, n_step + 1))
for step in pb:
self.rnn_encoder.train()
self.cnn_encoder.train()
self.optim.zero_grad()
cap, cap_len, img = to_device(dl.next(), device=self.device)
cap, cap_len, img = self.after_batch_tfm(cap, cap_len, img)
word_features, cnn_code = self.cnn_encoder(img)
sent_emb, word_emb = self.rnn_encoder(cap, cap_len)
s_loss0, s_loss1 = compute_sent_loss(cnn_code,
sent_emb,
gamma3=self.gamma3)
w_loss0, w_loss1, attn_maps = compute_word_loss(word_features,
word_emb,
cap_len,
gamma1=self.gamma1,
gamma2=self.gamma2,
gamma3=self.gamma3)
loss = s_loss0 + s_loss1 + w_loss0 + w_loss1
loss.backward()
torch.nn.utils.clip_grad_norm_(self.rnn_encoder.parameters(), 0.25)
self.optim.step()
losses.append(loss.detach().cpu())
pb.set_postfix(loss=loss.detach().cpu().numpy())
if saveck_every and step % saveck_every == 0:
self.save_checkpoint(path=ck_path + f'-{step//saveck_every}.pt')
if step % step_per_epoch == 0: # Each epoch
if self.lr_scheduler.get_last_lr(
)[0] > self.lr_scheduler.base_lrs[0] / 10:
self.lr_scheduler.step()
# print(self.lr_scheduler.get_last_lr()[0], self.lr_scheduler.base_lrs[0])
duration = time.time() - log_start_t
msg = f'{step//step_per_epoch}, time: {duration:.1f}s, loss: {torch.tensor(losses).mean():.4f}'
tqdm.write(msg)
losses = []
log_start_t = time.time()
pb.close()
tqdm.write(f'total_time: {(time.time()-total_start_t)/60:.1f}min')
def train(self, model: nn.Module, train_interactions: np.ndarray,
test_interactions: np.ndarray, is_sparse: bool):
optimizer: optim.Optimizer
if is_sparse:
optimizer = optim.SparseAdam(model.parameters(), lr=self.LR)
else:
optimizer = optim.Adam(model.parameters(),
lr=self.LR,
weight_decay=self.WEIGHT_DECAY)
train_loss_history = []
test_loss_history = []
train_dataset = get_dataset(train_interactions)
test_dataset = get_dataset(test_interactions)
test_users, test_movies, test_ratings = test_dataset.tensors
data_loader = DataLoader(train_dataset, batch_size=self.BATCH_SIZE)
model.to(DEVICE)
for epoch in tqdm(range(0, self.EPOCHS), desc='Training'):
train_loss = 0
for users_batch, movies_batch, ratings_batch in data_loader:
optimizer.zero_grad()
prediction = model(users_batch, movies_batch)
loss = self.loss(prediction, ratings_batch)
for regularizer in self.regularizers:
loss += regularizer(prediction)
loss.backward()
optimizer.step()
train_loss += loss.item()
test_prediction = model(test_users, test_movies)
test_loss = self.loss(test_prediction, test_ratings).item()
for regularizer in self.regularizers:
test_loss += regularizer(test_prediction).item()
train_loss /= len(data_loader)
train_loss_history.append(train_loss)
test_loss_history.append(test_loss)
if self.VERBOSE:
msg = f'Train loss: {train_loss:.3f}, '
msg += f'Test loss: {test_loss:.3f}'
tqdm.write(msg)
return train_loss_history, test_loss_history
def delete(self):
"""Deletes internal `message_id`."""
try:
future = self.submit(
self.session.post, self.API + '%s/deleteMessage' % self.token,
data={'chat_id': self.chat_id, 'message_id': self.message_id})
except Exception as e:
tqdm_auto.write(str(e))
else:
return future
def request(prompts: List[str]):
# Retry request (handles connection errors, timeouts, and overloaded API)
while True:
try:
return openai.Completion.create(engine=model_name_or_path,
prompt=prompts,
max_tokens=max_len,
n=1)
except Exception as e:
tqdm.write(str(e))
tqdm.write("Retrying...")
def __init__(self, token, channel_id):
"""Creates a new message in the given `channel_id`."""
super(DiscordIO, self).__init__()
config = ClientConfig()
config.token = token
client = Client(config)
self.text = self.__class__.__name__
try:
self.message = client.api.channels_messages_create(channel_id, self.text)
except Exception as e:
tqdm_auto.write(str(e))
def download_panorama_v4(panoid, zoom=5, max_retry=3):
'''
v4: save image information in a buffer. (v2: save image to dist then read)
input:
panoid: which is an id of image on google maps
zoom: larger number -> higher resolution, from 1 to 5, better less than 3, some location will fail when zoom larger than 3
output:
panorama image (uncropped)
'''
tile_height, tile_width = 512, 512
# img_w, img_h = int(np.ceil(416*(2**zoom)/tile_width)*tile_width), int(np.ceil(416*( 2**(zoom-1) )/tile_width)*tile_width)
img_w, img_h = 416*(2**zoom), 416*( 2**(zoom-1) )
tiles = get_tiles_info(panoid, zoom=zoom)
valid_tiles = []
tile_urls = []
# function of download_tiles
for i, tile in enumerate(tiles):
x, y, fname, url = tile
if x*tile_width < img_w and y*tile_height < img_h: # tile is valid
tile_urls.append(url)
tile_urls = np.array(tile_urls, dtype=str)
# Try to download the image file
valid_tiles = np.array([None] * len(tile_urls), dtype=object)
n_retry = 0
while any(valid_tiles == None) and n_retry < max_retry:
idxs = (valid_tiles == None).nonzero()[0]
if n_retry > 0:
tqdm.write(f"[download_panorama_v3] Connection error. Trying again in 2 seconds. {len(idxs)}/{len(valid_tiles)}")
time.sleep(2)
rs = (grequests.get(t_url, stream=True) for t_url in tile_urls[idxs])
res = grequests.map(rs)
for i, res_i in zip(idxs, res):
if res_i is not None:
try:
valid_tiles[i] = Image.open(BytesIO(res_i.content))
except PIL.UnidentifiedImageError:
continue
n_retry += 1
# If Not a valid tile, fill with black pixels
idxs = (valid_tiles == None).nonzero()[0]
if idxs.size > 0:
for idx in idxs:
valid_tiles[idx] = Image.new('RGB', (tile_width, tile_height))
# function to stich
panorama = Image.new('RGB', (img_w, img_h))
i = 0
for x, y, fname, url in tiles:
if x*tile_width < img_w and y*tile_height < img_h: # tile is valid
tile = valid_tiles[i]
i += 1
panorama.paste(im=tile, box=(x*tile_width, y*tile_height))
return np.array(panorama)
def _print_hyper_parameters(hyper_parameters):
"""
Prints parameters.
:param hyper_parameters: Dict with the hyper parameters.
"""
tqdm.write('-' * 80)
tqdm.write('Hyper-Parameters')
tqdm.write('-' * 80)
tqdm.write(pprint.pformat(hyper_parameters))
tqdm.write('-' * 80)
