def stest_one_versus_many(model, data_dir, img_size):
""" """
data_iterator = iter(
DataLoader(
PairDataset(
data_dir,
transform=transforms.Compose([
transforms.Grayscale(),
transforms.Resize(img_size),
transforms.ToTensor(),
]),
split=SplitEnum.testing,
),
num_workers=0,
batch_size=1,
shuffle=True,
))
x0, *_ = next(data_iterator)
for i in range(10):
_, x1, _ = next(data_iterator)
dis = (torch.pairwise_distance(*model(
to_tensor(x0, device=global_torch_device()),
to_tensor(x1, device=global_torch_device()),
)).cpu().item())
boxed_text_overlay_plot(
torchvision.utils.make_grid(torch.cat((x0, x1), 0)),
f"Dissimilarity: {dis:.2f}",
)
def run_seg_traced_webcam_demo():
"""
:return:
:rtype:"""
import torch
import io
load_path = (PROJECT_APP_PATH.user_data / "penn_fudan_segmentation" /
"seg_skip_fis").with_suffix(".traced")
# print(load_path)
# torch.jit.load(str(load_path))
with open(str(load_path),
"rb") as f: # Load ScriptModule from io.BytesIO object
buffer = io.BytesIO(f.read())
model = torch.jit.load(buffer) # Load all tensors to the original device
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
from matplotlib.pyplot import imshow
with TorchDeviceSession(device=global_torch_device("cpu"), model=model):
with TorchEvalSession(model):
for image in tqdm(frame_generator(cv2.VideoCapture(0))):
result = model(
transform(image).unsqueeze(0).to(global_torch_device()))[0]
imshow(result[0][0].numpy(), vmin=0.0, vmax=1.0)
show()
def main():
""" """
from configs.mobilenet_v2_ssd320_voc0712 import base_cfg
# from configs.efficient_net_b3_ssd300_voc0712 import base_cfg
# from configs.vgg_ssd300_coco_trainval35k import base_cfg
# from .configs.vgg_ssd512_coco_trainval35k import base_cfg
global_torch_device(override=global_torch_device("cpu"))
parser = argparse.ArgumentParser(description="SSD Demo.")
parser.add_argument(
"--ckpt",
type=str,
default=PROJECT_APP_PATH.user_data / "ssd" / "models" /
"mobilenet_v2_ssd320_voc0712.pth"
# "mobilenet_v2_ssd320_voc0712.pth"
# "vgg_ssd300_coco_trainval35k.pth"
# "vgg_ssd512_coco_trainval35k.pth"
,
help="Trained "
"weights.",
)
args = parser.parse_args()
export_detection_model(cfg=base_cfg, model_checkpoint=Path(args.ckpt))
def main():
from configs.mobilenet_v2_ssd320_voc0712 import base_cfg
# from configs.efficient_net_b3_ssd300_voc0712 import base_cfg
# from configs.vgg_ssd300_coco_trainval35k import base_cfg
# from .configs.vgg_ssd512_coco_trainval35k import base_cfg
global_torch_device(override=global_torch_device(cuda_if_available=False))
parser = argparse.ArgumentParser(description="SSD Demo.")
parser.add_argument(
"--ckpt",
type=str,
default=PROJECT_APP_PATH.user_data / "ssd" / "models" /
"mobilenet_v2_ssd320_voc0712.pth"
# "mobilenet_v2_ssd320_voc0712.pth"
# "vgg_ssd300_coco_trainval35k.pth"
# "vgg_ssd512_coco_trainval35k.pth"
,
help="Use weights from path",
)
parser.add_argument("--score_threshold", type=float, default=0.7)
args = parser.parse_args()
run_traced_webcam_demo(
input_cfg=base_cfg.input,
categories=base_cfg.dataset_type.category_sizes,
score_threshold=args.score_threshold,
)
def stest_many_versus_many(model, data_dir, img_size, threshold=0.5):
""" """
data_iterator = iter(
DataLoader(
PairDataset(
data_dir,
transform=transforms.Compose([
transforms.Grayscale(),
transforms.Resize(img_size),
transforms.ToTensor(),
]),
),
num_workers=0,
batch_size=1,
shuffle=True,
))
for i in range(10):
x0, x1, is_diff = next(data_iterator)
distance = (torch.pairwise_distance(*model(
to_tensor(x0, device=global_torch_device()),
to_tensor(x1, device=global_torch_device()),
)).cpu().item())
boxed_text_overlay_plot(
torchvision.utils.make_grid(torch.cat((x0, x1), 0)),
f"Truth: {'Different' if is_diff.cpu().item() else 'Alike'},"
f" Dissimilarity: {distance:.2f},"
f" Verdict: {'Different' if distance > threshold else 'Alike'}",
)
def __exit__(self, exc_type, exc_val, exc_tb):
if self._no_side_effect:
device = global_torch_device(override=self.prev_dev)
else:
device = global_torch_device(override=torch.device("cuda"))
if self._model:
self._model.to(device)
return False
def test_cpu():
print(
global_torch_device(override=global_torch_device(
device_preference=True)))
print(global_torch_device())
with TorchCpuSession():
print(global_torch_device())
print(global_torch_device())
def main(model_name: str = "maskrcnn_pennfudanped", score_threshold=0.55):
base_path = PROJECT_APP_PATH.user_data / 'maskrcnn'
dataset_root = Path.home() / "Data"
torch_seed(3825)
dataset = PennFudanDataset(dataset_root / "PennFudanPed",
Split.Training)
categories = dataset.categories
if True:
model = load_model(model_name=model_name,
model_directory=base_path / 'models')
else:
model = get_pretrained_instance_segmentation_maskrcnn(
dataset.response_channels)
model.to(global_torch_device())
cpu_device = torch.device("cpu")
with torch.no_grad():
with TorchEvalSession(model):
for image in tqdm(
to_tensor_generator(
frame_generator(cv2.VideoCapture(0)),
device=global_torch_device(),
)):
prediction = model(
# torch_vision_normalize_batch_nchw(
uint_hwc_to_chw_float_tensor(image).unsqueeze(0)
# )
)[0]
(boxes, labels, scores) = (
prediction["boxes"].to(cpu_device).numpy(),
prediction["labels"].to(cpu_device).numpy(),
torch.sigmoid(
prediction["scores"]).to(cpu_device).numpy(),
)
indices = scores > score_threshold
cv2.namedWindow(model_name, cv2.WINDOW_NORMAL)
cv2.imshow(
model_name,
draw_bounding_boxes(
quick_to_pil_image(image),
boxes[indices],
labels=labels[indices],
scores=scores[indices],
categories=categories,
))
if cv2.waitKey(1) == 27:
break # esc to quit
def main():
"""
"""
data_dir = Path.home() / "Data" / "mnist_png"
train_batch_size = 64
train_number_epochs = 100
save_path = PROJECT_APP_PATH.user_data / "models"
model_name = "pair_siamese_mnist"
load_prev = True
train = False
img_size = (28, 28)
model = PairRankingSiamese(img_size).to(global_torch_device())
optimiser = optim.Adam(model.parameters(), lr=3e-4)
if train:
if load_prev:
model, optimer = load_model_parameters(
model,
optimiser=optimiser,
model_name=model_name,
model_directory=save_path,
)
with TensorBoardPytorchWriter(PROJECT_APP_PATH.user_log /
model_name /
str(time.time())) as writer:
# with CaptureEarlyStop() as _:
with suppress(KeyboardInterrupt):
model = train_siamese(
model,
optimiser,
nn.BCELoss().to(global_torch_device()),
train_number_epochs=train_number_epochs,
data_dir=data_dir,
train_batch_size=train_batch_size,
model_name=model_name,
save_path=save_path,
writer=writer,
img_size=img_size,
)
save_model_parameters(
model,
optimiser=optimiser,
model_name=f"{model_name}",
save_directory=save_path,
)
else:
model = load_model_parameters(model,
model_name=model_name,
model_directory=save_path)
print("loaded best val")
stest_many_versus_many2(model, data_dir, img_size)
def main():
""" """
from configs.vgg_ssd300_coco_trainval35k import base_cfg
parser = argparse.ArgumentParser(
description="SSD Evaluation on VOC and COCO dataset."
)
parser.add_argument("--local_rank", type=int, default=0)
parser.add_argument(
"--ckpt",
help="The path to the checkpoint for test, default is the latest checkpoint.",
default=PROJECT_APP_PATH.user_data
/ "ssd"
/ "models"
/ "mobilenet_v2_ssd320_voc0712.pth"
# "mobilenet_v2_ssd320_voc0712.pth"
# "vgg_ssd300_coco_trainval35k.pth"
# "vgg_ssd512_coco_trainval35k.pth"
,
type=str,
)
args = parser.parse_args()
num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
distributed = num_gpus > 1
set_benchmark_device_dist(distributed, args.local_rank)
logger = setup_distributed_logger(
"SSD", global_distribution_rank(), PROJECT_APP_PATH.user_data / "results"
)
logger.info(f"Using {num_gpus} GPUs")
logger.info(args)
device = torch.device(base_cfg.MODEL.DEVICE)
global_torch_device(override=device)
with TorchCacheSession():
model = SingleShotDetection(base_cfg)
checkpointer = CheckPointer(
model,
save_dir=PROJECT_APP_PATH.user_data / "results",
logger=logging.getLogger("SSD.inference"),
)
checkpointer.load(args.ckpt, use_latest=args.ckpt is None)
do_ssd_evaluation(
base_cfg.data_dir,
base_cfg,
model.to(torch.device(base_cfg.MODEL.DEVICE)),
distributed,
)
def main(test_cuda=False):
print("-" * 80)
device = torch.device("cuda" if test_cuda else "cpu")
ct = CenterLoss(10, 2, size_average=True).to(global_torch_device())
y = torch.Tensor([0, 0, 2, 1]).to(global_torch_device())
feat = torch.zeros(4, 2).to(global_torch_device()).requires_grad_()
print(list(ct.parameters()))
print(ct.centers.grad)
out = ct(y, feat)
print(out.item())
out.backward()
print(ct.centers.grad)
print(feat.grad)
def main():
""" """
data_dir = Path.home() / "Data" / "mnist_png"
train_batch_size = 64
train_number_epochs = 100
save_path = PROJECT_APP_PATH.user_data / "models"
model_name = "triplet_siamese_mnist"
load_prev = True
train = False
img_size = (28, 28)
model = NLetConvNet(img_size).to(global_torch_device())
optimiser = optim.Adam(model.parameters(), lr=3e-4)
if train:
if load_prev:
model, optimiser = load_model_parameters(
model,
optimiser=optimiser,
model_name=model_name,
model_directory=save_path,
)
with TensorBoardPytorchWriter():
# from draugr.stopping import CaptureEarlyStop
# with CaptureEarlyStop() as _:
with IgnoreInterruptSignal():
model = train_siamese(
model,
optimiser,
TripletMarginLoss().to(global_torch_device()),
train_number_epochs=train_number_epochs,
data_dir=data_dir,
train_batch_size=train_batch_size,
model_name=model_name,
save_path=save_path,
img_size=img_size,
)
save_model_parameters(
model,
optimiser=optimiser,
model_name=f"{model_name}",
save_directory=save_path,
)
else:
model = load_model_parameters(model,
model_name=model_name,
model_directory=save_path)
print("loaded best val")
stest_many_versus_many(model, data_dir, img_size)
def main_binary(p=Path.home() / "Data" / "Datasets" / "PennFudanPed"):
dataset = PennFudanDataset(p, SplitEnum.training)
global_torch_device(override=global_torch_device("cpu"))
idx = -2
img, mask = dataset[idx]
print(img)
print(img.shape, mask.shape)
pyplot.imshow(float_chw_to_hwc_uint_tensor(img))
pyplot.show()
pyplot.imshow(mask.squeeze(0))
pyplot.show()
def run_seg_traced_webcam_demo():
"""
:param categories:
:type categories:
:param cfg:
:type cfg:
:param model_ckpt:
:type model_ckpt:
:param score_threshold:
:type score_threshold:
:param window_name:
:type window_name:
:return:
:rtype:
"""
import torch
import io
torch.jit.load("seg_skip_fis.traced")
with open(
"seg_skip_fis.traced", "rb"
) as f: # Load ScriptModule from io.BytesIO object
buffer = io.BytesIO(f.read())
model = torch.jit.load(buffer) # Load all tensors to the original device
transform = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
]
)
with TorchDeviceSession(
device=global_torch_device(cuda_if_available=False), model=model
):
with TorchEvalSession(model):
for image in tqdm(frame_generator(cv2.VideoCapture(0))):
result = model(transform(image).unsqueeze(0).to(global_torch_device()))[
0
]
print(result)
from matplotlib.pyplot import imshow
imshow(result[0][0].numpy(), vmin=0.0, vmax=1.0)
show()
def main():
""" """
from draugr.torch_utilities import global_torch_device
torch.manual_seed(999)
print("-" * 80)
ct = CenterLoss(10, 2, size_average=True).to(global_torch_device())
y = torch.Tensor([0, 0, 2, 1]).to(global_torch_device())
feat = torch.zeros(4, 2).to(global_torch_device()).requires_grad_()
print(list(ct.parameters()))
print(ct.centers.grad)
out = ct(y, feat)
print(out.item())
out.backward()
print(ct.centers.grad)
print(feat.grad)
def train_model(
model,
optimiser,
epoch_i: int,
metric_writer: Writer,
loader: DataLoader,
log_interval=10,
):
with TorchTrainSession(model):
train_accum_loss = 0
generator = tqdm(enumerate(loader))
for batch_idx, (original, *_) in generator:
original = original.to(global_torch_device())
optimiser.zero_grad()
reconstruction, mean, log_var = model(original)
loss = loss_function(reconstruction, original, mean, log_var)
loss.backward()
optimiser.step()
train_accum_loss += loss.item()
metric_writer.scalar("train_loss", loss.item())
if batch_idx % log_interval == 0:
generator.set_description(
f"Train Epoch: {epoch_i}"
f" [{batch_idx * len(original)}/"
f"{len(loader.dataset)}"
f" ({100. * batch_idx / len(loader):.0f}%)]\t"
f"Loss: {loss.item() / len(original):.6f}")
break
print(f"====> Epoch: {epoch_i}"
f" Average loss: {train_accum_loss / len(loader.dataset):.4f}")
def inference(model: Module, data_iterator: Iterator, denoise: bool = True):
"""
:param model:
:type model:
:param data_iterator:
:type data_iterator:
"""
with torch.no_grad():
with TorchEvalSession(model):
img, target = next(data_iterator)
if denoise:
model_input = img + torch.normal(mean=0.0,
std=0.1,
size=img.shape,
device=global_torch_device())
else:
model_input = img
pred, *_ = model(torch.clamp(model_input, 0.0, 1.0))
for i, (s, j) in enumerate(
zip(pred.cpu().numpy(),
model_input.cpu().numpy())):
pyplot.imshow(j[0])
pyplot.show()
pyplot.imshow(s[0])
pyplot.title(i)
pyplot.show()
break
def plot_manifold(
model: torch.nn.Module,
*,
out_path: Path = None,
n_img_x: int = 20,
n_img_y: int = 20,
img_h: int = 28,
img_w: int = 28,
sample_range: Number = 1,
device: Optional[torch.device] = global_torch_device(),
) -> None:
"""
:param model:
:param out_path:
:param n_img_x:
:param n_img_y:
:param img_h:
:param img_w:
:param sample_range:
:return:"""
vectors = sample_2d_latent_vectors(sample_range, n_img_x,
n_img_y).to(device)
encodings = torch.sigmoid(model(vectors)).to("cpu")
images = encodings.reshape(n_img_x * n_img_y, img_h, img_w, -1).numpy()
images *= 255
images = numpy.uint8(images)
compiled = compile_encoding_image(images, (n_img_y, n_img_x))
if out_path:
from imageio import imwrite
imwrite(str(out_path), compiled)
return compiled
def single_epoch_fitting(
model: torch.nn.Module,
optimiser,
train_loader_,
*,
epoch: int = None,
writer: Writer = None,
device_: torch.device = global_torch_device()) -> None:
accum_loss = 0
num_batches = len(train_loader_)
with TorchTrainSession(model):
for batch_idx, (data, target) in tqdm(enumerate(train_loader_),
desc='train batch #',
total=num_batches):
loss = nll_loss(
model(data.to(device_)).squeeze(), target.to(device_)
) # negative log-likelihood for a tensor of size (batch x 1 x n_output)
optimiser.zero_grad()
loss.backward()
optimiser.step()
accum_loss += loss.item()
if writer:
writer.scalar('loss', accum_loss / num_batches, epoch)
def __init__(
self,
*,
device: str = global_torch_device(True),
gradient_clipping: TogglableLowHigh = TogglableLowHigh(False, -1.0, 1.0),
gradient_norm_clipping: TogglableLowHigh = TogglableLowHigh(False, -1.0, 1.0),
intrinsic_signal_provider_arch: IntrinsicSignalProvider = BraindeadIntrinsicSignalProvider,
**kwargs,
):
"""
@param device:
@param gradient_clipping:
@param grad_clip_low:
@param grad_clip_high:
@param kwargs:
"""
super().__init__(
intrinsic_signal_provider_arch=intrinsic_signal_provider_arch, **kwargs
)
self._gradient_clipping = gradient_clipping
self._gradient_norm_clipping = gradient_norm_clipping
self._device = torch.device(
device if torch.cuda.is_available() and device != "cpu" else "cpu"
)
def maskrcnn_evaluate(
model: Module,
data_loader: DataLoader,
*,
device=global_torch_device(),
writer: Writer = None,
) -> CocoEvaluator:
"""
Args:
model:
data_loader:
device:
writer:
Returns:
"""
n_threads = torch.get_num_threads()
# FIXME remove this and make paste_masks_in_image run on the GPU
torch.set_num_threads(1)
cpu_device = torch.device("cpu")
coco_evaluator = CocoEvaluator(
get_coco_api_from_dataset(data_loader.dataset), get_iou_types(model))
with torch.no_grad():
with TorchEvalSession(model):
for image, targets in tqdm.tqdm(data_loader):
image = [img.to(device) for img in image]
targets = [{k: v.to(device)
for k, v in t.items()} for t in targets]
torch.cuda.synchronize(device)
model_time = time.time()
outputs = model(image)
outputs = [{k: v.to(cpu_device)
for k, v in t.items()} for t in outputs]
model_time = time.time() - model_time
res = {
target["image_id"].item(): output
for target, output in zip(targets, outputs)
}
evaluator_time = time.time()
coco_evaluator.update(res)
evaluator_time = time.time() - evaluator_time
if writer:
writer.scalar("model_time", model_time)
writer.scalar("evaluator_time", evaluator_time)
coco_evaluator.synchronize_between_processes()
coco_evaluator.accumulate()
coco_evaluator.summarize()
torch.set_num_threads(n_threads)
return coco_evaluator
def validate_model(model, valid_loader):
with TorchDeviceSession(global_torch_device("cpu"), model):
with torch.no_grad():
with TorchCacheSession():
with TorchEvalSession(model):
valid_masks = []
out_data = []
a = (256, 256)
tr = min(len(valid_loader.dataset) * 4, 2000)
probabilities = []
for sample_i, (data,
target) in enumerate(tqdm(valid_loader)):
data = data.to(global_torch_device())
outpu, *_ = model(data)
for m, d, p in zip(
target.cpu().detach().numpy(),
data.cpu().detach().numpy(),
torch.sigmoid(outpu).cpu().detach().numpy(),
):
out_data.append(cv2_resize(chw_to_hwc(d), a))
valid_masks.append(cv2_resize(m[0], a))
probabilities.append(cv2_resize(p[0], a))
sample_i += 1
if sample_i >= tr - 1:
break
if sample_i >= tr - 1:
break
min_a = min(3, len(out_data))
f, ax = pyplot.subplots(min_a, 3, figsize=(24, 12))
# assert len(valid_masks)>2, f'{len(valid_masks), tr}'
for i in range(min_a):
ax[0, i].imshow(out_data[i], vmin=0, vmax=1)
ax[0, i].set_title("Original", fontsize=14)
ax[1, i].imshow(valid_masks[i], vmin=0, vmax=1)
ax[1, i].set_title("Target", fontsize=14)
ax[2, i].imshow(probabilities[i], vmin=0, vmax=1)
ax[2, i].set_title("Prediction", fontsize=14)
pyplot.show()
def __init__(self,
device: torch.device,
model: Module = None,
no_side_effect: bool = True):
self._model = model
self._no_side_effect = no_side_effect
self._device = device
if no_side_effect:
self.prev_dev = global_torch_device()
def threshold_grid_search(model, valid_loader, max_samples=2000):
""" Grid Search for best Threshold """
valid_masks = []
count = 0
tr = min(valid_loader.dataset.__len__(), max_samples)
probabilities = numpy.zeros((tr, *CloudSegmentationDataset.image_size_T),
dtype=numpy.float32)
for data, targets in tqdm(valid_loader):
data = data.to(global_torch_device(), dtype=torch.float)
predictions, *_ = model(data)
predictions = torch.sigmoid(predictions)
predictions = predictions.cpu().detach().numpy()
targets = targets.cpu().detach().numpy()
for p in range(data.shape[0]):
pred, target = predictions[p], targets[p]
for mask_ in target:
valid_masks.append(mask_)
for probability in pred:
probabilities[count, :, :] = probability
count += 1
if count >= tr - 1:
break
if count >= tr - 1:
break
class_params = {}
for class_id in CloudSegmentationDataset.categories.keys():
print(CloudSegmentationDataset.categories[class_id])
attempts = []
for t in range(0, 100, 5):
t /= 100
for ms in [0, 100, 1200, 5000, 10000, 30000]:
masks, d = [], []
for i in range(class_id, len(probabilities), 4):
probability_ = probabilities[i]
predict, num_predict = threshold_mask(probability_, t, ms)
masks.append(predict)
for i, j in zip(masks, valid_masks[class_id::4]):
if (i.sum() == 0) & (j.sum() == 0):
d.append(1)
else:
d.append(intersection_over_union(i, j))
attempts.append((t, ms, numpy.mean(d)))
attempts_df = pandas.DataFrame(attempts,
columns=["threshold", "size", "dice"])
attempts_df = attempts_df.sort_values("dice", ascending=False)
print(attempts_df.head())
best_threshold = attempts_df["threshold"].values[0]
best_size = attempts_df["size"].values[0]
class_params[class_id] = (best_threshold, best_size)
return class_params
def main_instanced(p=Path.home() / "Data" / "Datasets" / "PennFudanPed"):
dataset = PennFudanDataset(
p,
SplitEnum.training,
return_variant=PennFudanDataset.PennFudanReturnVariantEnum.
instanced,
)
global_torch_device(override=global_torch_device("cpu"))
idx = -2
img, mask = dataset[idx]
print(img)
print(img.shape, mask.shape)
pyplot.imshow(float_chw_to_hwc_uint_tensor(img))
pyplot.show()
for m in mask:
pyplot.imshow(m.squeeze(0))
pyplot.show()
def stest_many_versus_many2(model: Module,
data_dir: Path,
img_size: Tuple[int, int],
threshold=0.5):
"""
:param model:
:type model:
:param data_dir:
:type data_dir:
:param img_size:
:type img_size:
:param threshold:
:type threshold:
"""
dataiter = iter(
DataLoader(
PairDataset(
data_dir,
transform=transforms.Compose([
transforms.Grayscale(),
transforms.Resize(img_size),
transforms.ToTensor(),
]),
),
num_workers=4,
batch_size=1,
shuffle=True,
))
for i in range(10):
x0, x1, is_diff = next(dataiter)
distance = (model(
to_tensor(x0, device=global_torch_device()),
to_tensor(x1, device=global_torch_device()),
).cpu().item())
boxed_text_overlay_plot(
torchvision.utils.make_grid(torch.cat((x0, x1), 0)),
f"Truth: {'Different' if is_diff.cpu().item() else 'Alike'},"
f" Dissimilarity: {distance:.2f},"
f" Verdict: {'Different' if distance > threshold else 'Alike'}",
)
def neodroid_env_classification_generator(env, batch_size=64) -> Tuple:
"""
:param env:
:param batch_size:
"""
while True:
predictors = []
class_responses = []
while len(predictors) < batch_size:
state = env.update()
rgb_arr = state.sensor("RGB").value
rgb_arr = Image.open(rgb_arr).convert("RGB")
a_class = state.sensor("Class").value
predictors.append(default_torch_transform(rgb_arr))
class_responses.append(int(a_class))
a = torch.stack(predictors).to(global_torch_device())
b = torch.LongTensor(class_responses).to(global_torch_device())
yield a, b
def discount_rollout_signal_torch(signal: torch.Tensor,
discounting_factor: float,
*,
device=global_torch_device(),
non_terminal=None,
batch_normalised=False,
epsilon=1e-3) -> Any:
"""
x = [r1, r2, r3, ..., rN]
returns [r1 + r2*gamma + r3*gamma^2 + ...,
r2 + r3*gamma + r4*gamma^2 + ...,
r3 + r4*gamma + r5*gamma^2 + ...,
..., ..., rN]
# See https://docs.scipy.org/doc/scipy/reference/tutorial/signal.html#difference-equation-filtering
# Here, we have y[t] - discount*y[t+1] = x[t]
# or rev(y)[t] - discount*rev(y)[t-1] = rev(x)[t]
C[i] = R[i] + discount * C[i+1]
signal.lfilter(b, a, x, axis=-1, zi=None)
a[0]*y[n] = b[0]*x[n] + b[1]*x[n-1] + ... + b[M]*x[n-M]
- a[1]*y[n-1] - ... - a[N]*y[n-N]
non_terminal if supplied lets you define a mask for masking terminal state signals.
@param signal:
@param discounting_factor:
@param device:
@param non_terminal:
@return:
"""
discounted = torch.zeros_like(signal, device=device)
R = torch.zeros(signal.shape[-1], device=device)
NT = torch.ones_like(signal, device=device)
if non_terminal is not None:
NT = to_tensor(non_terminal, device=device)
for i in reversed(range(signal.shape[0])):
R = signal[i] + discounting_factor * R * NT[i]
discounted[i] = R
if batch_normalised:
# WARNING! Sometimes causes NANs!
discounted = (discounted - discounted.mean()) / (discounted.std() +
epsilon)
return discounted
def prepare_submission(model,
class_params,
test_loader,
submission_file_path="submission.csv"):
"""
Args:
model:
class_params:
test_loader:
submission_file_path:
"""
# encoded_pixels = []
submission_i = 0
number_of_pixels_saved = 0
df: pandas.DataFrame = test_loader.dataset.data_frame
with open(submission_file_path, mode="w") as f:
f.write("Image_Label,EncodedPixels\n")
for data, target, black_mask in tqdm(test_loader):
data = data.to(global_torch_device(), dtype=torch.float)
output, *_ = model(data)
del data
output = torch.sigmoid(output)
output = output.cpu().detach().numpy()
black_mask = black_mask.cpu().detach().numpy()
a = df["Image_Label"]
for category in output:
for probability in category:
thr, min_size = (
class_params[submission_i % 4][0],
class_params[submission_i % 4][1],
)
predict, num_predict = threshold_mask(
probability, thr, min_size)
if num_predict == 0:
rle = ""
# encoded_pixels.append('')
else:
number_of_pixels_saved += numpy.sum(predict)
predict_masked = numpy.multiply(predict, black_mask)
number_of_pixels_saved -= numpy.sum(predict_masked)
rle = mask_to_run_length(predict_masked)
# encoded_pixels.append(rle)
f.write(f"{a[submission_i]},{rle}\n")
submission_i += 1
# df['EncodedPixels'] = encoded_pixels
# df.to_csv(submission_file_path, columns=['Image_Label', 'EncodedPixels'], index=False)
print(f"Number of pixel saved {number_of_pixels_saved}")
def maskrcnn_train_single_epoch(
*,
model: Module,
optimiser: torch.optim.Optimizer,
data_loader: DataLoader,
device: torch.device = global_torch_device(),
writer: Writer = None,
) -> None:
"""
:param model:
:param optimiser:
:param data_loader:
:param epoch_i:
:param log_frequency:
:param device:
:param writer:
:return:
"""
model.to(device)
with TorchTrainSession(model):
for images, targets in tqdm.tqdm(data_loader, desc="Batch #"):
images = [img.to(device) for img in images]
targets = [{k: v.to(device)
for k, v in t.items()} for t in targets]
# torch.cuda.synchronize(device)
loss_dict = model(images, targets=targets)
losses = sum(loss for loss in loss_dict.values())
loss_dict_reduced = reduce_dict(
loss_dict) # reduce losses over all GPUs for logging purposes
losses_reduced = sum(loss for loss in loss_dict_reduced.values())
loss_value = losses_reduced.item()
if not math.isfinite(loss_value):
print(f"Loss is {loss_value}, stopping training")
print(loss_dict_reduced)
sys.exit(1)
optimiser.zero_grad()
losses.backward()
optimiser.step()
if writer:
for k, v in {
"loss": losses_reduced,
"lr": torch.optim.Optimizer.param_groups[0]["lr"],
**loss_dict_reduced,
}.items():
writer.scalar(k, v)
