python_code
stringlengths 0
258k
|
|---|
from torchbenchmark.util.framework.timm.model_factory import TimmModel
from torchbenchmark.tasks import COMPUTER_VISION
class Model(TimmModel):
task = COMPUTER_VISION.CLASSIFICATION
DEFAULT_TRAIN_BSIZE = 32
DEFAULT_EVAL_BSIZE = 64
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, model_name='efficientnet_b0', device=device,
jit=jit, batch_size=batch_size, extra_args=extra_args)
|
"""
Maskrcnn model from torchvision
"""
import torch
import os
import itertools
import random
import numpy as np
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import COMPUTER_VISION
from pathlib import Path
from typing import Tuple
# Model specific imports
import torchvision
from .coco_utils import ConvertCocoPolysToMask
from torchvision.datasets.coco import CocoDetection
# silence some spam
from pycocotools import coco
coco.print = lambda *args: None
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = False
CURRENT_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
DATA_DIR = os.path.join(CURRENT_DIR.parent.parent, "data", ".data", "coco2017-minimal")
assert os.path.exists(DATA_DIR), "Couldn't find coco2017 minimal data dir, please run install.py again."
COCO_DATA_KEY = "coco_2017_val_100"
COCO_DATA = {
"coco_2017_val_100": ("coco/val2017", "coco/annotations/instances_val2017_100.json")
}
def _collate_fn(batch):
return tuple(zip(*batch))
def _prefetch(loader, device):
items = []
for images, targets in loader:
images = list(image.to(device) for image in images)
targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
items.append((images, targets))
return items
class Model(BenchmarkModel):
task = COMPUTER_VISION.DETECTION
DEFAULT_TRAIN_BSIZE = 4
DEFAULT_EVAL_BSIZE = 4
NUM_OF_BATCHES = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
# reduce the eval batch size when running on CPU
# see: https://github.com/pytorch/benchmark/issues/895
if device == "cpu":
self.DEFAULT_EVAL_BSIZE = 1
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = torchvision.models.detection.maskrcnn_resnet50_fpn(
weights=torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights.COCO_V1
).to(self.device)
# setup optimizer
# optimizer parameters copied from
# https://github.com/pytorch/vision/blob/30f4d108319b0cd28ae5662947e300aad98c32e9/references/detection/train.py#L77
lr = 0.02
momentum = 0.9
weight_decay = 1e-4
params = [p for p in self.model.parameters() if p.requires_grad]
self.optimizer = torch.optim.SGD(params, lr=lr, momentum=momentum, weight_decay=weight_decay)
transforms = ConvertCocoPolysToMask()
dataset = CocoDetection(root=os.path.join(DATA_DIR, COCO_DATA[COCO_DATA_KEY][0]),
annFile=os.path.join(DATA_DIR, COCO_DATA[COCO_DATA_KEY][1]),
transforms=transforms)
sampler = torch.utils.data.SequentialSampler(dataset)
self.data_loader = _prefetch(torch.utils.data.DataLoader(dataset, batch_size=self.batch_size,
sampler=sampler,
collate_fn=_collate_fn), self.device)
def get_module(self):
self.model.eval()
for (example_inputs, _example_targets) in self.data_loader:
return self.model, (example_inputs, )
def train(self):
self.model.train()
for _batch_id, (images, targets) in zip(range(self.NUM_OF_BATCHES), self.data_loader):
# images = list(image.to(self.device) for image in images)
# targets = [{k: v.to(self.device) for k, v in t.items()} for t in targets]
loss_dict = self.model(images, targets)
losses = sum(loss for loss in loss_dict.values())
self.optimizer.zero_grad()
losses.backward()
self.optimizer.step()
def eval(self) -> Tuple[torch.Tensor]:
self.model.eval()
with torch.no_grad():
for _batch_id, (images, _targets) in zip(range(self.NUM_OF_BATCHES), self.data_loader):
out = self.model(images)
out = list(map(lambda x: x.values(), out))
return tuple(itertools.chain(*out))
|
import os
import sys
import subprocess
from pathlib import Path
def setup_data_dir():
current_dir = Path(os.path.dirname(os.path.realpath(__file__)))
coco2017_data_dir = os.path.join(current_dir.parent.parent, "data", ".data", "coco2017-minimal")
assert os.path.exists(coco2017_data_dir), "Couldn't find coco2017 minimal data dir, please run install.py again."
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
setup_data_dir()
pip_install_requirements()
|
import torch
from pycocotools import mask as coco_mask
from torchvision.transforms import functional as F
def convert_coco_poly_to_mask(segmentations, height, width):
masks = []
for polygons in segmentations:
rles = coco_mask.frPyObjects(polygons, height, width)
mask = coco_mask.decode(rles)
if len(mask.shape) < 3:
mask = mask[..., None]
mask = torch.as_tensor(mask, dtype=torch.uint8)
mask = mask.any(dim=2)
masks.append(mask)
if masks:
masks = torch.stack(masks, dim=0)
else:
masks = torch.zeros((0, height, width), dtype=torch.uint8)
return masks
class ConvertCocoPolysToMask:
def __call__(self, image, target):
w, h = image.size
image_id = target[0]["image_id"] if target else []
image_id = torch.tensor([image_id])
anno = target
anno = [obj for obj in anno if obj["iscrowd"] == 0]
boxes = [obj["bbox"] for obj in anno]
# guard against no boxes via resizing
boxes = torch.as_tensor(boxes, dtype=torch.float32).reshape(-1, 4)
boxes[:, 2:] += boxes[:, :2]
boxes[:, 0::2].clamp_(min=0, max=w)
boxes[:, 1::2].clamp_(min=0, max=h)
classes = [obj["category_id"] for obj in anno]
classes = torch.tensor(classes, dtype=torch.int64)
segmentations = [obj["segmentation"] for obj in anno]
masks = convert_coco_poly_to_mask(segmentations, h, w)
keypoints = None
if anno and "keypoints" in anno[0]:
keypoints = [obj["keypoints"] for obj in anno]
keypoints = torch.as_tensor(keypoints, dtype=torch.float32)
num_keypoints = keypoints.shape[0]
if num_keypoints:
keypoints = keypoints.view(num_keypoints, -1, 3)
keep = (boxes[:, 3] > boxes[:, 1]) & (boxes[:, 2] > boxes[:, 0])
boxes = boxes[keep]
classes = classes[keep]
masks = masks[keep]
if keypoints is not None:
keypoints = keypoints[keep]
target = {}
target["boxes"] = boxes
target["labels"] = classes
target["masks"] = masks
target["image_id"] = image_id
if keypoints is not None:
target["keypoints"] = keypoints
# for conversion to coco api
area = torch.tensor([obj["area"] for obj in anno])
iscrowd = torch.tensor([obj["iscrowd"] for obj in anno])
target["area"] = area
target["iscrowd"] = iscrowd
# Convert image from PIL to tensor
image = F.pil_to_tensor(image)
image = F.convert_image_dtype(image)
return image, target
|
import os
import logging
import torch
from pathlib import Path
from contextlib import suppress
# TorchBench imports
from torchbenchmark.util.model import BenchmarkModel
from torchbenchmark.tasks import COMPUTER_VISION
# effdet imports
from effdet import create_model, create_loader
from effdet.data import resolve_input_config
# timm imports
from timm.models.layers import set_layer_config
from timm.optim import create_optimizer
from timm.utils import ModelEmaV2, NativeScaler
from timm.scheduler import create_scheduler
# local imports
from .args import get_args
from .train import train_epoch, validate
from .loader import create_datasets_and_loaders
from torch.utils._pytree import tree_map
from typing import Tuple
# setup coco2017 input path
CURRENT_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
DATA_DIR = os.path.join(CURRENT_DIR.parent.parent, "data", ".data", "coco2017-minimal", "coco")
def prefetch(loader, device, num_of_batches):
prefetched_loader = []
for _bid, (input, target) in zip(range(num_of_batches), loader):
prefetched_loader.append((tree_map(lambda x: x.to(device, dtype=torch.float32) if isinstance(x, torch.Tensor) else x, input),
tree_map(lambda x: x.to(device, dtype=torch.float32) if isinstance(x, torch.Tensor) else x, target)))
return prefetched_loader
class Model(BenchmarkModel):
task = COMPUTER_VISION.DETECTION
# Original Train batch size 32 on 2x RTX 3090 (24 GB cards)
# Downscale to batch size 16 on single GPU
DEFAULT_TRAIN_BSIZE = 16
DEFAULT_EVAL_BSIZE = 128
# prefetch only 1 batch
NUM_OF_BATCHES = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
if not device == "cuda":
# Only implemented on CUDA because the original model code explicitly calls the `Tensor.cuda()` API
# https://github.com/rwightman/efficientdet-pytorch/blob/9cb43186711d28bd41f82f132818c65663b33c1f/effdet/data/loader.py#L114
raise NotImplementedError("The original model code forces the use of CUDA.")
# generate arguments
args = get_args()
# setup train and eval batch size
args.batch_size = self.batch_size
# Disable distributed
args.distributed = False
args.device = self.device
args.torchscript = self.jit
args.world_size = 1
args.rank = 0
args.pretrained_backbone = not args.no_pretrained_backbone
args.prefetcher = not args.no_prefetcher
args.root = DATA_DIR
with set_layer_config(scriptable=args.torchscript):
timm_extra_args = {}
if args.img_size is not None:
timm_extra_args = dict(image_size=(args.img_size, args.img_size))
if test == "train":
model = create_model(
model_name=args.model,
bench_task='train',
num_classes=args.num_classes,
pretrained=args.pretrained,
pretrained_backbone=args.pretrained_backbone,
redundant_bias=args.redundant_bias,
label_smoothing=args.smoothing,
legacy_focal=args.legacy_focal,
jit_loss=args.jit_loss,
soft_nms=args.soft_nms,
bench_labeler=args.bench_labeler,
checkpoint_path=args.initial_checkpoint,
)
elif test == "eval":
model = create_model(
model_name=args.model,
bench_task='predict',
num_classes=args.num_classes,
pretrained=args.pretrained,
redundant_bias=args.redundant_bias,
soft_nms=args.soft_nms,
checkpoint_path=args.checkpoint,
checkpoint_ema=args.use_ema,
**timm_extra_args,
)
model_config = model.config # grab before we obscure with DP/DDP wrappers
self.model = model.to(device)
if args.channels_last:
self.model = self.model.to(memory_format=torch.channels_last)
self.loader_train, self.loader_eval, self.evaluator, _, dataset_eval = create_datasets_and_loaders(args, model_config)
self.amp_autocast = suppress
if test == "train":
self.optimizer = create_optimizer(args, model)
self.loss_scaler = None
self.model_ema = None
if args.model_ema:
# Important to create EMA model after cuda(), DP wrapper, and AMP but before SyncBN and DDP wrapper
self.model_ema = ModelEmaV2(model, decay=args.model_ema_decay)
self.lr_scheduler, self.num_epochs = create_scheduler(args, self.optimizer)
if model_config.num_classes < self.loader_train.dataset.parser.max_label:
logging.error(
f'Model {model_config.num_classes} has fewer classes than dataset {self.loader_train.dataset.parser.max_label}.')
exit(1)
if model_config.num_classes > self.loader_train.dataset.parser.max_label:
logging.warning(
f'Model {model_config.num_classes} has more classes than dataset {self.loader_train.dataset.parser.max_label}.')
self.loader_train = prefetch(self.loader_train, self.device, self.NUM_OF_BATCHES)
self.loader_eval = prefetch(self.loader_eval, self.device, self.NUM_OF_BATCHES)
self.loader = self.loader_train
elif test == "eval":
# Create eval loader
input_config = resolve_input_config(args, model_config)
self.loader = create_loader(
dataset_eval,
input_size=input_config['input_size'],
batch_size=args.batch_size,
use_prefetcher=args.prefetcher,
interpolation=args.eval_interpolation,
fill_color=input_config['fill_color'],
mean=input_config['mean'],
std=input_config['std'],
num_workers=args.workers,
pin_mem=args.pin_mem)
self.loader = prefetch(self.loader, self.device, self.NUM_OF_BATCHES)
self.args = args
# Only run 1 epoch
self.num_epochs = 1
def get_module(self):
for _, (input, target) in zip(range(self.NUM_OF_BATCHES), self.loader):
return self.model, (input, target)
def get_optimizer(self):
return self.optimizer
def set_optimizer(self, optimizer) -> None:
self.optimizer = optimizer
self.lr_scheduler, self.num_epochs = create_scheduler(args, self.optimizer)
def enable_amp(self):
if self.device == "cuda":
self.amp_autocast = torch.cuda.amp.autocast
elif self.device == "cpu":
self.amp_autocast = torch.cpu.amp.autocast
self.loss_scaler = NativeScaler()
def train(self):
eval_metric = self.args.eval_metric
for epoch in range(self.num_epochs):
train_metrics = train_epoch(
epoch, self.model, self.loader_train,
self.optimizer, self.args,
lr_scheduler=self.lr_scheduler, amp_autocast = self.amp_autocast,
loss_scaler=self.loss_scaler, model_ema=self.model_ema,
num_batch=self.NUM_OF_BATCHES,
)
# TorchBench: skip validation step in train
# the overhead of evaluating with coco style datasets is fairly high, so just ema or non, not both
# if self.model_ema is not None:
# eval_metrics = validate(self.model_ema.module, self.loader_eval, self.args, self.evaluator, log_suffix=' (EMA)', num_batch=self.NUM_OF_BATCHES)
# else:
# eval_metrics = validate(self.model, self.loader_eval, self.args, self.evaluator, num_batch=self.NUM_OF_BATCHES)
# if self.lr_scheduler is not None:
# # step LR for next epoch
# self.lr_scheduler.step(epoch + 1, eval_metrics[eval_metric])
def eval(self) -> Tuple[torch.Tensor]:
with torch.no_grad():
for input, target in self.loader:
with self.amp_autocast():
output = self.model(input, img_info=target)
self.evaluator.add_predictions(output, target)
return (output, )
|
from effdet.data import resolve_input_config, SkipSubset
from effdet import create_loader, create_dataset, create_evaluator
from effdet.anchors import Anchors, AnchorLabeler
from effdet.data.dataset_config import CocoCfg
from dataclasses import dataclass, field
from typing import Dict
@dataclass
class Coco2017MinimalCfg(CocoCfg):
variant: str = '2017-minimal'
splits: Dict[str, dict] = field(default_factory=lambda: dict(
train=dict(ann_filename='annotations/instances_val2017_100.json', img_dir='val2017', has_labels=True),
val=dict(ann_filename='annotations/instances_val2017_100.json', img_dir='val2017', has_labels=True),
))
def create_datasets_and_loaders(
args,
model_config,
transform_train_fn=None,
transform_eval_fn=None,
collate_fn=None,
):
""" Setup datasets, transforms, loaders, evaluator.
Args:
args: Command line args / config for training
model_config: Model specific configuration dict / struct
transform_train_fn: Override default image + annotation transforms (see note in loaders.py)
transform_eval_fn: Override default image + annotation transforms (see note in loaders.py)
collate_fn: Override default fast collate function
Returns:
Train loader, validation loader, evaluator
"""
input_config = resolve_input_config(args, model_config=model_config)
dataset_train, dataset_eval = create_dataset(args.dataset, args.root, custom_dataset_cfg=Coco2017MinimalCfg())
# setup labeler in loader/collate_fn if not enabled in the model bench
labeler = None
if not args.bench_labeler:
labeler = AnchorLabeler(
Anchors.from_config(model_config), model_config.num_classes, match_threshold=0.5)
loader_train = create_loader(
dataset_train,
input_size=input_config['input_size'],
batch_size=args.batch_size,
is_training=True,
use_prefetcher=args.prefetcher,
re_prob=args.reprob,
re_mode=args.remode,
re_count=args.recount,
# color_jitter=args.color_jitter,
# auto_augment=args.aa,
interpolation=args.train_interpolation or input_config['interpolation'],
fill_color=input_config['fill_color'],
mean=input_config['mean'],
std=input_config['std'],
num_workers=args.workers,
distributed=args.distributed,
pin_mem=args.pin_mem,
anchor_labeler=labeler,
transform_fn=transform_train_fn,
collate_fn=collate_fn,
)
if args.val_skip > 1:
dataset_eval = SkipSubset(dataset_eval, args.val_skip)
loader_eval = create_loader(
dataset_eval,
input_size=input_config['input_size'],
batch_size=args.batch_size,
is_training=False,
use_prefetcher=args.prefetcher,
interpolation=input_config['interpolation'],
fill_color=input_config['fill_color'],
mean=input_config['mean'],
std=input_config['std'],
num_workers=args.workers,
distributed=args.distributed,
pin_mem=args.pin_mem,
anchor_labeler=labeler,
transform_fn=transform_eval_fn,
collate_fn=collate_fn,
)
evaluator = create_evaluator(args.dataset, loader_eval.dataset, distributed=args.distributed, pred_yxyx=False)
return loader_train, loader_eval, evaluator, dataset_train, dataset_eval |
import torch
from collections import OrderedDict
from contextlib import suppress
from timm.utils import AverageMeter, reduce_tensor
def train_epoch(
epoch, model, loader, optimizer, args,
lr_scheduler=None, saver=None, output_dir='', amp_autocast=suppress, loss_scaler=None, model_ema=None,
num_batch=1):
# batch_time_m = AverageMeter()
# data_time_m = AverageMeter()
losses_m = AverageMeter()
model.train()
# end = time.time()
last_idx = len(loader) - 1
num_updates = epoch * len(loader)
for batch_idx, (input, target) in zip(range(num_batch), loader):
last_batch = batch_idx == last_idx
# data_time_m.update(time.time() - end)
if args.channels_last:
input = input.contiguous(memory_format=torch.channels_last)
with amp_autocast():
output = model(input, target)
loss = output['loss']
if not args.distributed:
losses_m.update(loss.item(), input.size(0))
optimizer.zero_grad()
if loss_scaler is not None:
loss_scaler(loss, optimizer, clip_grad=args.clip_grad, parameters=model.parameters())
else:
loss.backward()
if args.clip_grad:
torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip_grad)
optimizer.step()
torch.cuda.synchronize()
if model_ema is not None:
model_ema.update(model)
num_updates += 1
# batch_time_m.update(time.time() - end)
if last_batch or batch_idx % args.log_interval == 0:
lrl = [param_group['lr'] for param_group in optimizer.param_groups]
lr = sum(lrl) / len(lrl)
# if args.distributed:
# reduced_loss = reduce_tensor(loss.data, args.world_size)
# losses_m.update(reduced_loss.item(), input.size(0))
#
# if args.local_rank == 0:
# logging.info(
# 'Train: {} [{:>4d}/{} ({:>3.0f}%)] '
# 'Loss: {loss.val:>9.6f} ({loss.avg:>6.4f}) '
# 'Time: {batch_time.val:.3f}s, {rate:>7.2f}/s '
# '({batch_time.avg:.3f}s, {rate_avg:>7.2f}/s) '
# 'LR: {lr:.3e} '
# 'Data: {data_time.val:.3f} ({data_time.avg:.3f})'.format(
# epoch,
# batch_idx, len(loader),
# 100. * batch_idx / last_idx,
# loss=losses_m,
# batch_time=batch_time_m,
# rate=input.size(0) * args.world_size / batch_time_m.val,
# rate_avg=input.size(0) * args.world_size / batch_time_m.avg,
# lr=lr,
# data_time=data_time_m))
# if args.save_images and output_dir:
# torchvision.utils.save_image(
# input,
# os.path.join(output_dir, 'train-batch-%d.jpg' % batch_idx),
# padding=0,
# normalize=True)
# if saver is not None and args.recovery_interval and (
# last_batch or (batch_idx + 1) % args.recovery_interval == 0):
# saver.save_recovery(epoch, batch_idx=batch_idx)
if lr_scheduler is not None:
lr_scheduler.step_update(num_updates=num_updates, metric=losses_m.avg)
# end = time.time()
# end for
if hasattr(optimizer, 'sync_lookahead'):
optimizer.sync_lookahead()
return OrderedDict([('loss', losses_m.avg)])
def validate(model, loader, args, evaluator=None, log_suffix='',
num_batch=1):
# batch_time_m = AverageMeter()
losses_m = AverageMeter()
model.eval()
# end = time.time()
# last_idx = len(loader) - 1
with torch.no_grad():
for batch_idx, (input, target) in zip(range(num_batch), loader):
# last_batch = batch_idx == last_idx
output = model(input, target)
loss = output['loss']
if evaluator is not None:
evaluator.add_predictions(output['detections'], target)
if args.distributed:
reduced_loss = reduce_tensor(loss.data, args.world_size)
else:
reduced_loss = loss.data
torch.cuda.synchronize()
losses_m.update(reduced_loss.item(), input.size(0))
# batch_time_m.update(time.time() - end)
# end = time.time()
# if args.local_rank == 0 and (last_batch or batch_idx % args.log_interval == 0):
# log_name = 'Test' + log_suffix
# logging.info(
# '{0}: [{1:>4d}/{2}] '
# 'Time: {batch_time.val:.3f} ({batch_time.avg:.3f}) '
# 'Loss: {loss.val:>7.4f} ({loss.avg:>6.4f}) '.format(
# log_name, batch_idx, last_idx, batch_time=batch_time_m, loss=losses_m))
metrics = OrderedDict([('loss', losses_m.avg)])
if evaluator is not None:
metrics['map'] = evaluator.evaluate()
return metrics |
import yaml
import argparse
from timm.utils import add_bool_arg
def get_args(config_file=None):
def _parse_args():
if config_file:
with open(config_file, 'r') as f:
cfg = yaml.safe_load(f)
parser.set_defaults(**cfg)
# There may be remaining unrecognized options
# The main arg parser parses the rest of the args, the usual
# defaults will have been overridden if config file specified.
args, _ = parser.parse_known_args()
# Cache the args as a text string to save them in the output dir later
args_text = yaml.safe_dump(args.__dict__, default_flow_style=False)
return args, args_text
# The first arg parser parses out only the --config argument, this argument is used to
# load a yaml file containing key-values that override the defaults for the main parser below
parser = argparse.ArgumentParser(description='Training Config', add_help=False)
parser.add_argument('-c', '--config', default='', type=str, metavar='FILE',
help='YAML config file specifying default arguments')
parser = argparse.ArgumentParser(description='PyTorch ImageNet Training')
# Dataset / Model parameters
# parser.add_argument('root', metavar='DIR',
# help='path to dataset')
parser.add_argument('--dataset', default='coco', type=str, metavar='DATASET',
help='Name of dataset to train (default: "coco"')
parser.add_argument('--model', default='tf_efficientdet_d1', type=str, metavar='MODEL',
help='Name of model to train (default: "tf_efficientdet_d1"')
add_bool_arg(parser, 'redundant-bias', default=None, help='override model config for redundant bias')
add_bool_arg(parser, 'soft-nms', default=None, help='override model config for soft-nms')
parser.add_argument('--val-skip', type=int, default=0, metavar='N',
help='Skip every N validation samples.')
parser.add_argument('--num-classes', type=int, default=None, metavar='N',
help='Override num_classes in model config if set. For fine-tuning from pretrained.')
parser.add_argument('--pretrained', action='store_true', default=False,
help='Start with pretrained version of specified network (if avail)')
parser.add_argument('--no-pretrained-backbone', action='store_true', default=False,
help='Do not start with pretrained backbone weights, fully random.')
parser.add_argument('--initial-checkpoint', default='', type=str, metavar='PATH',
help='Initialize model from this checkpoint (default: none)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='Resume full model and optimizer state from checkpoint (default: none)')
parser.add_argument('--no-resume-opt', action='store_true', default=False,
help='prevent resume of optimizer state when resuming model')
parser.add_argument('--mean', type=float, nargs='+', default=None, metavar='MEAN',
help='Override mean pixel value of dataset')
parser.add_argument('--std', type=float, nargs='+', default=None, metavar='STD',
help='Override std deviation of of dataset')
parser.add_argument('--interpolation', default='', type=str, metavar='NAME',
help='Image resize interpolation type (overrides model)')
parser.add_argument('--fill-color', default=None, type=str, metavar='NAME',
help='Image augmentation fill (background) color ("mean" or int)')
parser.add_argument('--batch-size', type=int, default=32, metavar='N',
help='input batch size for training (default: 32)')
parser.add_argument('--clip-grad', type=float, default=10.0, metavar='NORM',
help='Clip gradient norm (default: 10.0)')
# Optimizer parameters
parser.add_argument('--opt', default='momentum', type=str, metavar='OPTIMIZER',
help='Optimizer (default: "momentum"')
parser.add_argument('--opt-eps', default=1e-3, type=float, metavar='EPSILON',
help='Optimizer Epsilon (default: 1e-3)')
parser.add_argument('--momentum', type=float, default=0.9, metavar='M',
help='SGD momentum (default: 0.9)')
parser.add_argument('--weight-decay', type=float, default=4e-5,
help='weight decay (default: 0.00004)')
# Learning rate schedule parameters
parser.add_argument('--sched', default='cosine', type=str, metavar='SCHEDULER',
help='LR scheduler (default: "step"')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--lr-noise', type=float, nargs='+', default=None, metavar='pct, pct',
help='learning rate noise on/off epoch percentages')
parser.add_argument('--lr-noise-pct', type=float, default=0.67, metavar='PERCENT',
help='learning rate noise limit percent (default: 0.67)')
parser.add_argument('--lr-noise-std', type=float, default=1.0, metavar='STDDEV',
help='learning rate noise std-dev (default: 1.0)')
parser.add_argument('--lr-cycle-mul', type=float, default=1.0, metavar='MULT',
help='learning rate cycle len multiplier (default: 1.0)')
parser.add_argument('--lr-cycle-limit', type=int, default=1, metavar='N',
help='learning rate cycle limit')
parser.add_argument('--warmup-lr', type=float, default=0.0001, metavar='LR',
help='warmup learning rate (default: 0.0001)')
parser.add_argument('--min-lr', type=float, default=1e-5, metavar='LR',
help='lower lr bound for cyclic schedulers that hit 0 (1e-5)')
parser.add_argument('--epochs', type=int, default=300, metavar='N',
help='number of epochs to train (default: 2)')
parser.add_argument('--start-epoch', default=None, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
parser.add_argument('--decay-epochs', type=float, default=30, metavar='N',
help='epoch interval to decay LR')
parser.add_argument('--warmup-epochs', type=int, default=5, metavar='N',
help='epochs to warmup LR, if scheduler supports')
parser.add_argument('--cooldown-epochs', type=int, default=10, metavar='N',
help='epochs to cooldown LR at min_lr, after cyclic schedule ends')
parser.add_argument('--patience-epochs', type=int, default=10, metavar='N',
help='patience epochs for Plateau LR scheduler (default: 10')
parser.add_argument('--decay-rate', '--dr', type=float, default=0.1, metavar='RATE',
help='LR decay rate (default: 0.1)')
# Augmentation parameters
parser.add_argument('--color-jitter', type=float, default=0.4, metavar='PCT',
help='Color jitter factor (default: 0.4)')
parser.add_argument('--aa', type=str, default=None, metavar='NAME',
help='Use AutoAugment policy. "v0" or "original". (default: None)'),
parser.add_argument('--reprob', type=float, default=0., metavar='PCT',
help='Random erase prob (default: 0.)')
parser.add_argument('--remode', type=str, default='pixel',
help='Random erase mode (default: "pixel")')
parser.add_argument('--recount', type=int, default=1,
help='Random erase count (default: 1)')
parser.add_argument('--train-interpolation', type=str, default='random',
help='Training interpolation (random, bilinear, bicubic default: "random")')
# loss
parser.add_argument('--smoothing', type=float, default=None, help='override model config label smoothing')
add_bool_arg(parser, 'jit-loss', default=None, help='override model config for torchscript jit loss fn')
add_bool_arg(parser, 'legacy-focal', default=None, help='override model config to use legacy focal loss')
# Model Exponential Moving Average
parser.add_argument('--model-ema', action='store_true', default=False,
help='Enable tracking moving average of model weights')
parser.add_argument('--model-ema-decay', type=float, default=0.9998,
help='decay factor for model weights moving average (default: 0.9998)')
# Misc
parser.add_argument('--sync-bn', action='store_true',
help='Enable NVIDIA Apex or Torch synchronized BatchNorm.')
parser.add_argument('--dist-bn', type=str, default='',
help='Distribute BatchNorm stats between nodes after each epoch ("broadcast", "reduce", or "")')
parser.add_argument('--seed', type=int, default=42, metavar='S',
help='random seed (default: 42)')
parser.add_argument('--log-interval', type=int, default=50, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--recovery-interval', type=int, default=0, metavar='N',
help='how many batches to wait before writing recovery checkpoint')
parser.add_argument('-j', '--workers', type=int, default=0, metavar='N',
help='how many training processes to use (default: 0)')
parser.add_argument('--save-images', action='store_true', default=False,
help='save images of input bathes every log interval for debugging')
parser.add_argument('--amp', action='store_true', default=False,
help='use NVIDIA Apex AMP or Native AMP for mixed precision training')
parser.add_argument('--apex-amp', action='store_true', default=False,
help='Use NVIDIA Apex AMP mixed precision')
parser.add_argument('--native-amp', action='store_true', default=False,
help='Use Native Torch AMP mixed precision')
parser.add_argument('--channels-last', action='store_true', default=False,
help='Use channels_last memory layout')
parser.add_argument('--pin-mem', action='store_true', default=False,
help='Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.')
parser.add_argument('--no-prefetcher', action='store_true', default=False,
help='disable fast prefetcher')
parser.add_argument('--torchscript', dest='torchscript', action='store_true',
help='convert model torchscript for inference')
add_bool_arg(parser, 'bench-labeler', default=False,
help='label targets in model bench, increases GPU load at expense of loader processes')
parser.add_argument('--output', default='', type=str, metavar='PATH',
help='path to output folder (default: none, current dir)')
parser.add_argument('--eval-metric', default='map', type=str, metavar='EVAL_METRIC',
help='Best metric (default: "map"')
parser.add_argument('--tta', type=int, default=0, metavar='N',
help='Test/inference time augmentation (oversampling) factor. 0=None (default: 0)')
parser.add_argument("--local_rank", default=0, type=int)
# Evaluation parameters
parser.add_argument('--eval-interpolation', default='bilinear', type=str, metavar='NAME',
help='Image resize interpolation type (overrides model)')
parser.add_argument('--img-size', default=None, type=int,
metavar='N', help='Input image dimension, uses model default if empty')
parser.add_argument('--checkpoint', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
parser.add_argument('--use-ema', dest='use_ema', action='store_true',
help='use ema version of weights if present')
args, _ = _parse_args()
return args
|
import os
import sys
import patch
from pathlib import Path
import subprocess
def check_data_dir():
current_dir = Path(os.path.dirname(os.path.realpath(__file__)))
coco2017_data_dir = os.path.join(current_dir.parent.parent, "data", ".data", "coco2017-minimal")
assert os.path.exists(coco2017_data_dir), "Couldn't find coco2017 minimal data dir, please run install.py again."
def patch_effdet():
import effdet
current_dir = os.path.dirname(os.path.abspath(__file__))
patch_file = os.path.join(current_dir, "effdet.patch")
target_dir = os.path.dirname(effdet.__file__)
p = patch.fromfile(patch_file)
if not p.apply(strip=1, root=target_dir):
print("Failed to patch effdet. Exit.")
exit(1)
def patch_pycocotools():
import pycocotools
current_dir = os.path.dirname(os.path.abspath(__file__))
patch_file = os.path.join(current_dir, "pycocotools.patch")
target_dir = os.path.dirname(os.path.abspath(pycocotools.__file__))
p = patch.fromfile(patch_file)
if not p.apply(strip=1, root=target_dir):
print("Failed to patch pycocotools. Exit.")
exit(1)
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
check_data_dir()
pip_install_requirements()
patch_effdet()
patch_pycocotools()
|
from torchbenchmark.util.framework.timm.model_factory import TimmModel
from torchbenchmark.tasks import COMPUTER_VISION
class Model(TimmModel):
task = COMPUTER_VISION.GENERATION
DEFAULT_TRAIN_BSIZE = 32
DEFAULT_EVAL_BSIZE = 32
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, model_name='vit_giant_patch14_224', device=device,
jit=jit, batch_size=batch_size, extra_args=extra_args)
|
from torchbenchmark.tasks import NLP
from torchbenchmark.util.framework.huggingface.model_factory import HuggingFaceModel
class Model(HuggingFaceModel):
task = NLP.LANGUAGE_MODELING
DEFAULT_TRAIN_BSIZE = 4
DEFAULT_EVAL_BSIZE = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(name="hf_Bart", test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import subprocess
import sys
import os
from torchbenchmark.util.framework.huggingface.patch_hf import patch_transformers, cache_model
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
patch_transformers()
model_name = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
cache_model(model_name)
|
import numpy as np
import random
import time
import torch
from argparse import Namespace
from .meta import Meta
from pathlib import Path
from typing import Tuple
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import OTHER
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
DEFAULT_TRAIN_BSIZE = 1
DEFAULT_EVAL_BSIZE = 1
ALLOW_CUSTOMIZE_BSIZE = False
CANNOT_SET_CUSTOM_OPTIMIZER = True
# Skip correctness check, because maml runs backward and optimizer in eval()
# Which will return non-deterministic results
SKIP_CORRECTNESS_CHECK = True
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
# load from disk or synthesize data
use_data_file = False
debug_print = False
root = str(Path(__file__).parent)
args = Namespace(**{
'n_way': 5,
'k_spt': 1,
'k_qry': 15,
'imgsz': 28,
'imgc': 1,
'task_num': 32,
'meta_lr': 1e-3,
'update_lr': 0.4,
'update_step': 5,
'update_step_test': 10
})
config = [
('conv2d', [64, args.imgc, 3, 3, 2, 0]),
('relu', [True]),
('bn', [64]),
('conv2d', [64, 64, 3, 3, 2, 0]),
('relu', [True]),
('bn', [64]),
('conv2d', [64, 64, 3, 3, 2, 0]),
('relu', [True]),
('bn', [64]),
('conv2d', [64, 64, 2, 2, 1, 0]),
('relu', [True]),
('bn', [64]),
('flatten', []),
('linear', [args.n_way, 64])
]
self.module = Meta(args, config).to(device)
if use_data_file:
self.example_inputs = torch.load(f'{root}/batch.pt')
self.example_inputs = tuple([torch.from_numpy(i).to(self.device) for i in self.example_inputs])
else:
# synthesize data parameterized by arg values
self.example_inputs = (
torch.randn(args.task_num, args.n_way, args.imgc, args.imgsz, args.imgsz).to(device),
torch.randint(0, args.n_way, [args.task_num, args.n_way], dtype=torch.long).to(device),
torch.randn(args.task_num, args.n_way * args.k_qry, args.imgc, args.imgsz, args.imgsz).to(device),
torch.randint(0, args.n_way, [args.task_num, args.n_way * args.k_qry], dtype=torch.long).to(device))
# print input shapes
if debug_print:
for i in range(len(self.example_inputs)):
print(self.example_inputs[i].shape)
def get_module(self):
return self.module, self.example_inputs
def eval(self) -> Tuple[torch.Tensor]:
out = self.module(*self.example_inputs)
return (out, )
def train(self):
raise NotImplementedError("MAML model doesn't support train.")
def eval_in_nograd(self):
return False
|
import torch
from torch import nn
from torch import optim
from torch.nn import functional as F
from torch.utils.data import TensorDataset, DataLoader
from torch import optim
import numpy as np
from .learner import Learner
from copy import deepcopy
class Meta(nn.Module):
"""
Meta Learner
"""
def __init__(self, args, config):
"""
:param args:
"""
super(Meta, self).__init__()
self.update_lr = args.update_lr
self.meta_lr = args.meta_lr
self.n_way = args.n_way
self.k_spt = args.k_spt
self.k_qry = args.k_qry
self.task_num = args.task_num
self.update_step = args.update_step
self.update_step_test = args.update_step_test
self.net = Learner(config, args.imgc, args.imgsz)
self.meta_optim = optim.Adam(self.net.parameters(), lr=self.meta_lr)
def clip_grad_by_norm_(self, grad, max_norm):
"""
in-place gradient clipping.
:param grad: list of gradients
:param max_norm: maximum norm allowable
:return:
"""
total_norm = 0
counter = 0
for g in grad:
param_norm = g.data.norm(2)
total_norm += param_norm.item() ** 2
counter += 1
total_norm = total_norm ** (1. / 2)
clip_coef = max_norm / (total_norm + 1e-6)
if clip_coef < 1:
for g in grad:
g.data.mul_(clip_coef)
return total_norm/counter
def forward(self, x_spt, y_spt, x_qry, y_qry):
if self.training:
return self.forward_train(x_spt, y_spt, x_qry, y_qry)
else:
return self.finetunning(x_spt[0], y_spt[0], x_qry[0], y_qry[0])
def forward_train(self, x_spt, y_spt, x_qry, y_qry):
"""
:param x_spt: [b, setsz, c_, h, w]
:param y_spt: [b, setsz]
:param x_qry: [b, querysz, c_, h, w]
:param y_qry: [b, querysz]
:return:
"""
task_num, setsz, c_, h, w = x_spt.size()
querysz = x_qry.size(1)
losses_q = [0 for _ in range(self.update_step + 1)] # losses_q[i] is the loss on step i
corrects = [0 for _ in range(self.update_step + 1)]
for i in range(task_num):
# 1. run the i-th task and compute loss for k=0
logits = self.net(x_spt[i], vars=None, bn_training=True)
loss = F.cross_entropy(logits, y_spt[i])
grad = torch.autograd.grad(loss, self.net.parameters())
fast_weights = list([p[1] - self.update_lr * p[0]for p in zip(grad, self.net.parameters())])
# this is the loss and accuracy before first update
with torch.no_grad():
# [setsz, nway]
logits_q = self.net(x_qry[i], self.net.parameters(), bn_training=True)
loss_q = F.cross_entropy(logits_q, y_qry[i])
losses_q[0] += loss_q
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
correct = torch.eq(pred_q, y_qry[i]).sum().item()
corrects[0] = corrects[0] + correct
# this is the loss and accuracy after the first update
with torch.no_grad():
# [setsz, nway]
logits_q = self.net(x_qry[i], fast_weights, bn_training=True)
loss_q = F.cross_entropy(logits_q, y_qry[i])
losses_q[1] += loss_q
# [setsz]
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
correct = torch.eq(pred_q, y_qry[i]).sum().item()
corrects[1] = corrects[1] + correct
for k in range(1, self.update_step):
# 1. run the i-th task and compute loss for k=1~K-1
logits = self.net(x_spt[i], fast_weights, bn_training=True)
loss = F.cross_entropy(logits, y_spt[i])
# 2. compute grad on theta_pi
grad = torch.autograd.grad(loss, fast_weights)
# 3. theta_pi = theta_pi - train_lr * grad
fast_weights = [p[1] - self.update_lr * p[0] for p in zip(grad, fast_weights)]
logits_q = self.net(x_qry[i], fast_weights, bn_training=True)
# loss_q will be overwritten and just keep the loss_q on last update step.
loss_q = F.cross_entropy(logits_q, y_qry[i])
losses_q[k + 1] += loss_q
with torch.no_grad():
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
correct = torch.eq(pred_q, y_qry[i]).sum().item() # convert to numpy
corrects[k + 1] = corrects[k + 1] + correct
# end of all tasks
# sum over all losses on query set across all tasks
loss_q = losses_q[-1] / task_num
# optimize theta parameters
self.meta_optim.zero_grad()
loss_q.backward()
# print('meta update')
# for p in self.net.parameters()[:5]:
# print(torch.norm(p).item())
self.meta_optim.step()
accs = torch.tensor(corrects) / (querysz * task_num)
return accs
def finetunning(self, x_spt, y_spt, x_qry, y_qry):
"""
:param x_spt: [setsz, c_, h, w]
:param y_spt: [setsz]
:param x_qry: [querysz, c_, h, w]
:param y_qry: [querysz]
:return:
"""
querysz = x_qry.size(0)
corrects = [0 for _ in range(self.update_step_test + 1)]
# in order to not ruin the state of running_mean/variance and bn_weight/bias
# we finetunning on the copied model instead of self.net
net = deepcopy(self.net)
# 1. run the i-th task and compute loss for k=0
logits = net(x_spt)
loss = F.cross_entropy(logits, y_spt)
grad = torch.autograd.grad(loss, net.parameters())
fast_weights = list(map(lambda p: p[1] - self.update_lr * p[0], zip(grad, net.parameters())))
# this is the loss and accuracy before first update
with torch.no_grad():
# [setsz, nway]
logits_q = net(x_qry, net.parameters(), bn_training=True)
# [setsz]
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
# scalar
correct = torch.eq(pred_q, y_qry).sum().item()
corrects[0] = corrects[0] + correct
# this is the loss and accuracy after the first update
with torch.no_grad():
# [setsz, nway]
logits_q = net(x_qry, fast_weights, bn_training=True)
# [setsz]
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
# scalar
correct = torch.eq(pred_q, y_qry).sum().item()
corrects[1] = corrects[1] + correct
for k in range(1, self.update_step_test):
# 1. run the i-th task and compute loss for k=1~K-1
logits = net(x_spt, fast_weights, bn_training=True)
loss = F.cross_entropy(logits, y_spt)
# 2. compute grad on theta_pi
grad = torch.autograd.grad(loss, fast_weights)
# 3. theta_pi = theta_pi - train_lr * grad
fast_weights = list(map(lambda p: p[1] - self.update_lr * p[0], zip(grad, fast_weights)))
logits_q = net(x_qry, fast_weights, bn_training=True)
# loss_q will be overwritten and just keep the loss_q on last update step.
loss_q = F.cross_entropy(logits_q, y_qry)
with torch.no_grad():
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
correct = torch.eq(pred_q, y_qry).sum().item() # convert to numpy
corrects[k + 1] = corrects[k + 1] + correct
del net
accs = torch.tensor(corrects) / querysz
return accs
def main():
pass
if __name__ == '__main__':
main()
|
import torch
from torch import nn
from torch.nn import functional as F
import numpy as np
from typing import List
class Learner(nn.Module):
"""
"""
def __init__(self, config, imgc, imgsz):
"""
:param config: network config file, type:list of (string, list)
:param imgc: 1 or 3
:param imgsz: 28 or 84
"""
super(Learner, self).__init__()
self.config = config
# this dict contains all tensors needed to be optimized
self.vars = nn.ParameterList()
# running_mean and running_var
self.vars_bn = nn.ParameterList()
for i, (name, param) in enumerate(self.config):
if name == 'conv2d':
# [ch_out, ch_in, kernelsz, kernelsz]
w = nn.Parameter(torch.ones(*param[:4]))
# gain=1 according to cbfin's implementation
torch.nn.init.kaiming_normal_(w)
self.vars.append(w)
# [ch_out]
self.vars.append(nn.Parameter(torch.zeros(param[0])))
elif name == 'convt2d':
# [ch_in, ch_out, kernelsz, kernelsz, stride, padding]
w = nn.Parameter(torch.ones(*param[:4]))
# gain=1 according to cbfin's implementation
torch.nn.init.kaiming_normal_(w)
self.vars.append(w)
# [ch_in, ch_out]
self.vars.append(nn.Parameter(torch.zeros(param[1])))
elif name == 'linear':
# [ch_out, ch_in]
w = nn.Parameter(torch.ones(*param))
# gain=1 according to cbfinn's implementation
torch.nn.init.kaiming_normal_(w)
self.vars.append(w)
# [ch_out]
self.vars.append(nn.Parameter(torch.zeros(param[0])))
elif name == 'bn':
# [ch_out]
w = nn.Parameter(torch.ones(param[0]))
self.vars.append(w)
# [ch_out]
self.vars.append(nn.Parameter(torch.zeros(param[0])))
# must set requires_grad=False
running_mean = nn.Parameter(torch.zeros(param[0]), requires_grad=False)
running_var = nn.Parameter(torch.ones(param[0]), requires_grad=False)
self.vars_bn.extend([running_mean, running_var])
elif name in ['tanh', 'relu', 'upsample', 'avg_pool2d', 'max_pool2d',
'flatten', 'reshape', 'leakyrelu', 'sigmoid']:
continue
else:
raise NotImplementedError
def extra_repr(self):
info = ''
for name, param in self.config:
if name == 'conv2d':
tmp = 'conv2d:(ch_in:%d, ch_out:%d, k:%dx%d, stride:%d, padding:%d)'\
%(param[1], param[0], param[2], param[3], param[4], param[5],)
info += tmp + '\n'
elif name == 'convt2d':
tmp = 'convTranspose2d:(ch_in:%d, ch_out:%d, k:%dx%d, stride:%d, padding:%d)'\
%(param[0], param[1], param[2], param[3], param[4], param[5],)
info += tmp + '\n'
elif name == 'linear':
tmp = 'linear:(in:%d, out:%d)'%(param[1], param[0])
info += tmp + '\n'
elif name == 'leakyrelu':
tmp = 'leakyrelu:(slope:%f)'%(param[0])
info += tmp + '\n'
elif name == 'avg_pool2d':
tmp = 'avg_pool2d:(k:%d, stride:%d, padding:%d)'%(param[0], param[1], param[2])
info += tmp + '\n'
elif name == 'max_pool2d':
tmp = 'max_pool2d:(k:%d, stride:%d, padding:%d)'%(param[0], param[1], param[2])
info += tmp + '\n'
elif name in ['flatten', 'tanh', 'relu', 'upsample', 'reshape', 'sigmoid', 'use_logits', 'bn']:
tmp = name + ':' + str(tuple(param))
info += tmp + '\n'
else:
raise NotImplementedError
return info
def forward(self, x, vars=None, bn_training=True):
"""
This function can be called by finetunning, however, in finetunning, we dont wish to update
running_mean/running_var. Thought weights/bias of bn == updated, it has been separated by fast_weights.
Indeed, to not update running_mean/running_var, we need set update_bn_statistics=False
but weight/bias will be updated and not dirty initial theta parameters via fast_weiths.
:param x: [b, 1, 28, 28]
:param vars:
:param bn_training: set False to not update
:return: x, loss, likelihood, kld
"""
if vars == None:
vars = self.vars
idx = 0
bn_idx = 0
for name, param in self.config:
if name == 'conv2d':
w, b = vars[idx], vars[idx + 1]
# remember to keep synchrozied of forward_encoder and forward_decoder!
x = F.conv2d(x, w, b, stride=param[4], padding=param[5])
idx += 2
# print(name, param, '\tout:', x.shape)
elif name == 'convt2d':
w, b = vars[idx], vars[idx + 1]
# remember to keep synchrozied of forward_encoder and forward_decoder!
x = F.conv_transpose2d(x, w, b, stride=param[4], padding=param[5])
idx += 2
# print(name, param, '\tout:', x.shape)
elif name == 'linear':
w, b = vars[idx], vars[idx + 1]
x = F.linear(x, w, b)
idx += 2
# print('forward:', idx, x.norm().item())
elif name == 'bn':
w, b = vars[idx], vars[idx + 1]
running_mean, running_var = self.vars_bn[bn_idx], self.vars_bn[bn_idx+1]
x = F.batch_norm(x, running_mean, running_var, weight=w, bias=b, training=bn_training)
idx += 2
bn_idx += 2
elif name == 'flatten':
# print(x.shape)
x = x.view(x.size(0), -1)
elif name == 'reshape':
# [b, 8] => [b, 2, 2, 2]
x = x.view(x.size(0), *param)
elif name == 'relu':
x = F.relu(x, inplace=param[0])
elif name == 'leakyrelu':
x = F.leaky_relu(x, negative_slope=param[0], inplace=param[1])
elif name == 'tanh':
x = F.tanh(x)
elif name == 'sigmoid':
x = torch.sigmoid(x)
elif name == 'upsample':
x = F.upsample_nearest(x, scale_factor=param[0])
elif name == 'max_pool2d':
x = F.max_pool2d(x, param[0], param[1], param[2])
elif name == 'avg_pool2d':
x = F.avg_pool2d(x, param[0], param[1], param[2])
else:
raise NotImplementedError
# make sure variable == used properly
assert idx == len(vars)
assert bn_idx == len(self.vars_bn)
return x
def zero_grad(self, vars=None):
"""
:param vars:
:return:
"""
with torch.no_grad():
if vars == None:
for p in self.vars:
if not p.grad == None:
p.grad.zero_()
else:
for p in vars:
if not p.grad == None:
p.grad.zero_()
def parameters(self):
"""
override this function since initial parameters will return with a generator.
:return:
"""
return self.vars |
from torchbenchmark.tasks import NLP
from torchbenchmark.util.framework.huggingface.model_factory import HuggingFaceModel
class Model(HuggingFaceModel):
task = NLP.LANGUAGE_MODELING
DEFAULT_TRAIN_BSIZE = 4
DEFAULT_EVAL_BSIZE = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(name="hf_Bert", test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import subprocess
import sys
import os
from torchbenchmark.util.framework.huggingface.patch_hf import patch_transformers, cache_model
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
patch_transformers()
model_name = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
cache_model(model_name)
|
import torch
from . import tke_pytorch
from typing import Tuple
from torchbenchmark.tasks import OTHER
from ...util.model import BenchmarkModel
def _generate_inputs(size):
import numpy as np
import math
np.random.seed(17)
shape = (
math.ceil(2 * size ** (1 / 3)),
math.ceil(2 * size ** (1 / 3)),
math.ceil(0.25 * size ** (1 / 3)),
)
# masks
maskU, maskV, maskW = (
(np.random.rand(*shape) < 0.8).astype("float64") for _ in range(3)
)
# 1d arrays
dxt, dxu = (np.random.randn(shape[0]) for _ in range(2))
dyt, dyu = (np.random.randn(shape[1]) for _ in range(2))
dzt, dzw = (np.random.randn(shape[2]) for _ in range(2))
cost, cosu = (np.random.randn(shape[1]) for _ in range(2))
# 2d arrays
kbot = np.random.randint(0, shape[2], size=shape[:2])
forc_tke_surface = np.random.randn(*shape[:2])
# 3d arrays
kappaM, mxl, forc = (np.random.randn(*shape) for _ in range(3))
# 4d arrays
u, v, w, tke, dtke = (np.random.randn(*shape, 3) for _ in range(5))
return (
u,
v,
w,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
kbot,
kappaM,
mxl,
forc,
forc_tke_surface,
tke,
dtke,
)
class TurbulentKineticEnergy(torch.nn.Module):
def __init__(self, device):
super(TurbulentKineticEnergy, self).__init__()
self.device = device
def forward(
self,
u,
v,
w,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
kbot,
kappaM,
mxl,
forc,
forc_tke_surface,
tke,
dtke,
):
# tke and dtke will be modified in integrate_tke and generate inconsistent results
# so clone them before passing them in
return tke_pytorch.integrate_tke(
u,
v,
w,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
kbot,
kappaM,
mxl,
forc,
forc_tke_surface,
torch.clone(tke),
torch.clone(dtke),
)
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
# Original input size: [2 ** i for i in range(12, 23, 2)]
# Source: https://github.com/dionhaefner/pyhpc-benchmarks/blob/650ecc650e394df829944ffcf09e9d646ec69691/run.py#L25
# Pick data-point when i = 20, size = 1048576
DEFAULT_EVAL_BSIZE = 1048576
CANNOT_SET_CUSTOM_OPTIMIZER = True
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = TurbulentKineticEnergy(self.device).to(device=self.device)
input_size = self.batch_size
self.example_inputs = tuple(
torch.from_numpy(x).to(self.device) for x in _generate_inputs(input_size)
)
def get_module(self):
return self.model, self.example_inputs
def train(self):
raise NotImplementedError("Training not supported")
def eval(self) -> Tuple[torch.Tensor]:
model, example_inputs = self.get_module()
with torch.no_grad():
out = model(*example_inputs)
return out
|
import torch
def solve_tridiag(a, b, c, d):
"""
Solves a tridiagonal matrix system with diagonals a, b, c and RHS vector d.
"""
assert a.shape == b.shape and a.shape == c.shape and a.shape == d.shape
n = a.shape[-1]
for i in range(1, n):
w = a[..., i] / b[..., i - 1]
b[..., i] += -w * c[..., i - 1]
d[..., i] += -w * d[..., i - 1]
out = torch.empty_like(a)
out[..., -1] = d[..., -1] / b[..., -1]
for i in range(n - 2, -1, -1):
out[..., i] = (d[..., i] - c[..., i] * out[..., i + 1]) / b[..., i]
return out
def solve_implicit(ks, a, b, c, d, b_edge):
land_mask = (ks >= 0)[:, :, None]
edge_mask = land_mask & (
torch.arange(a.shape[2], device=ks.device)[None, None, :] == ks[:, :, None]
)
water_mask = land_mask & (
torch.arange(a.shape[2], device=ks.device)[None, None, :] >= ks[:, :, None]
)
a_tri = water_mask * a * torch.logical_not(edge_mask)
b_tri = torch.where(water_mask, b, 1.0)
b_tri = torch.where(edge_mask, b_edge, b_tri)
c_tri = water_mask * c
d_tri = water_mask * d
return solve_tridiag(a_tri, b_tri, c_tri, d_tri), water_mask
def _calc_cr(rjp, rj, rjm, vel):
"""
Calculates cr value used in superbee advection scheme
"""
eps = 1e-20 # prevent division by 0
return torch.where(vel > 0.0, rjm, rjp) / torch.where(torch.abs(rj) < eps, eps, rj)
def pad_z_edges(arr):
arr_shape = list(arr.shape)
arr_shape[2] += 2
out = torch.zeros(arr_shape, dtype=arr.dtype, device=arr.device)
out[:, :, 1:-1] = arr
return out
def limiter(cr):
return torch.maximum(
torch.tensor([0.0], device=cr.device),
torch.maximum(
torch.minimum(torch.tensor([1.0], device=cr.device), 2 * cr),
torch.minimum(torch.tensor([2.0], device=cr.device), cr),
),
)
def _adv_superbee(vel, var, mask, dx, axis: int, cost, cosu, dt_tracer: float):
if axis == 0:
dx = cost[None, 2:-2, None] * dx[1:-2, None, None]
uCFL = torch.abs(vel[1:-2, 2:-2, :] * dt_tracer / dx)
rjp = (var[3:, 2:-2, :] - var[2:-1, 2:-2, :]) * mask[2:-1, 2:-2, :]
rj = (var[2:-1, 2:-2, :] - var[1:-2, 2:-2, :]) * mask[1:-2, 2:-2, :]
rjm = (var[1:-2, 2:-2, :] - var[:-3, 2:-2, :]) * mask[:-3, 2:-2, :]
cr = limiter(_calc_cr(rjp, rj, rjm, vel[1:-2, 2:-2, :]))
return (
vel[1:-2, 2:-2, :] * (var[2:-1, 2:-2, :] + var[1:-2, 2:-2, :]) * 0.5
- torch.abs(vel[1:-2, 2:-2, :]) * ((1.0 - cr) + uCFL * cr) * rj * 0.5
)
elif axis == 1:
dx = (cost * dx)[None, 1:-2, None]
velfac = cosu[None, 1:-2, None]
uCFL = torch.abs(velfac * vel[2:-2, 1:-2, :] * dt_tracer / dx)
rjp = (var[2:-2, 3:, :] - var[2:-2, 2:-1, :]) * mask[2:-2, 2:-1, :]
rj = (var[2:-2, 2:-1, :] - var[2:-2, 1:-2, :]) * mask[2:-2, 1:-2, :]
rjm = (var[2:-2, 1:-2, :] - var[2:-2, :-3, :]) * mask[2:-2, :-3, :]
cr = limiter(_calc_cr(rjp, rj, rjm, vel[2:-2, 1:-2, :]))
return (
velfac
* vel[2:-2, 1:-2, :]
* (var[2:-2, 2:-1, :] + var[2:-2, 1:-2, :])
* 0.5
- torch.abs(velfac * vel[2:-2, 1:-2, :])
* ((1.0 - cr) + uCFL * cr)
* rj
* 0.5
)
elif axis == 2:
vel, var, mask = [pad_z_edges(a) for a in (vel, var, mask)]
dx = dx[None, None, :-1]
uCFL = torch.abs(vel[2:-2, 2:-2, 1:-2] * dt_tracer / dx)
rjp = (var[2:-2, 2:-2, 3:] - var[2:-2, 2:-2, 2:-1]) * mask[2:-2, 2:-2, 2:-1]
rj = (var[2:-2, 2:-2, 2:-1] - var[2:-2, 2:-2, 1:-2]) * mask[2:-2, 2:-2, 1:-2]
rjm = (var[2:-2, 2:-2, 1:-2] - var[2:-2, 2:-2, :-3]) * mask[2:-2, 2:-2, :-3]
cr = limiter(_calc_cr(rjp, rj, rjm, vel[2:-2, 2:-2, 1:-2]))
return (
vel[2:-2, 2:-2, 1:-2]
* (var[2:-2, 2:-2, 2:-1] + var[2:-2, 2:-2, 1:-2])
* 0.5
- torch.abs(vel[2:-2, 2:-2, 1:-2]) * ((1.0 - cr) + uCFL * cr) * rj * 0.5
)
else:
raise ValueError("axis must be 0, 1, or 2")
def adv_flux_superbee_wgrid(
adv_fe,
adv_fn,
adv_ft,
var,
u_wgrid,
v_wgrid,
w_wgrid,
maskW,
dxt,
dyt,
dzw,
cost,
cosu,
dt_tracer: float,
):
"""
Calculates advection of a tracer defined on Wgrid
"""
maskUtr = torch.zeros_like(maskW)
maskUtr[:-1, :, :] = maskW[1:, :, :] * maskW[:-1, :, :]
adv_fe[...] = 0.0
adv_fe[1:-2, 2:-2, :] = _adv_superbee(
u_wgrid, var, maskUtr, dxt, 0, cost, cosu, dt_tracer
)
maskVtr = torch.zeros_like(maskW)
maskVtr[:, :-1, :] = maskW[:, 1:, :] * maskW[:, :-1, :]
adv_fn[...] = 0.0
adv_fn[2:-2, 1:-2, :] = _adv_superbee(
v_wgrid, var, maskVtr, dyt, 1, cost, cosu, dt_tracer
)
maskWtr = torch.zeros_like(maskW)
maskWtr[:, :, :-1] = maskW[:, :, 1:] * maskW[:, :, :-1]
adv_ft[...] = 0.0
adv_ft[2:-2, 2:-2, :-1] = _adv_superbee(
w_wgrid, var, maskWtr, dzw, 2, cost, cosu, dt_tracer
)
def integrate_tke(
u,
v,
w,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
kbot,
kappaM,
mxl,
forc,
forc_tke_surface,
tke,
dtke,
):
tau = 0
taup1 = 1
taum1 = 2
dt_tracer = 1.0
dt_mom = 1
AB_eps = 0.1
alpha_tke = 1.0
c_eps = 0.7
K_h_tke = 2000.0
flux_east = torch.zeros_like(maskU)
flux_north = torch.zeros_like(maskU)
flux_top = torch.zeros_like(maskU)
sqrttke = torch.sqrt(
torch.maximum(torch.tensor([0.0], device=tke.device), tke[:, :, :, tau])
)
"""
integrate Tke equation on W grid with surface flux boundary condition
"""
dt_tke = dt_mom # use momentum time step to prevent spurious oscillations
"""
vertical mixing and dissipation of TKE
"""
ks = kbot[2:-2, 2:-2] - 1
a_tri = torch.zeros_like(maskU[2:-2, 2:-2])
b_tri = torch.zeros_like(maskU[2:-2, 2:-2])
c_tri = torch.zeros_like(maskU[2:-2, 2:-2])
d_tri = torch.zeros_like(maskU[2:-2, 2:-2])
delta = torch.zeros_like(maskU[2:-2, 2:-2])
delta[:, :, :-1] = (
dt_tke
/ dzt[None, None, 1:]
* alpha_tke
* 0.5
* (kappaM[2:-2, 2:-2, :-1] + kappaM[2:-2, 2:-2, 1:])
)
a_tri[:, :, 1:-1] = -delta[:, :, :-2] / dzw[None, None, 1:-1]
a_tri[:, :, -1] = -delta[:, :, -2] / (0.5 * dzw[-1])
b_tri[:, :, 1:-1] = (
1
+ (delta[:, :, 1:-1] + delta[:, :, :-2]) / dzw[None, None, 1:-1]
+ dt_tke * c_eps * sqrttke[2:-2, 2:-2, 1:-1] / mxl[2:-2, 2:-2, 1:-1]
)
b_tri[:, :, -1] = (
1
+ delta[:, :, -2] / (0.5 * dzw[-1])
+ dt_tke * c_eps / mxl[2:-2, 2:-2, -1] * sqrttke[2:-2, 2:-2, -1]
)
b_tri_edge = (
1
+ delta / dzw[None, None, :]
+ dt_tke * c_eps / mxl[2:-2, 2:-2, :] * sqrttke[2:-2, 2:-2, :]
)
c_tri[:, :, :-1] = -delta[:, :, :-1] / dzw[None, None, :-1]
d_tri[...] = tke[2:-2, 2:-2, :, tau] + dt_tke * forc[2:-2, 2:-2, :]
d_tri[:, :, -1] += dt_tke * forc_tke_surface[2:-2, 2:-2] / (0.5 * dzw[-1])
sol, water_mask = solve_implicit(ks, a_tri, b_tri, c_tri, d_tri, b_edge=b_tri_edge)
tke[2:-2, 2:-2, :, taup1] = torch.where(water_mask, sol, tke[2:-2, 2:-2, :, taup1])
"""
Add TKE if surface density flux drains TKE in uppermost box
"""
tke_surf_corr = torch.zeros(maskU.shape[:2], device=maskU.device)
mask = tke[2:-2, 2:-2, -1, taup1] < 0.0
tke_surf_corr[2:-2, 2:-2] = torch.where(
mask, -tke[2:-2, 2:-2, -1, taup1] * 0.5 * dzw[-1] / dt_tke, 0.0
)
tke[2:-2, 2:-2, -1, taup1] = torch.maximum(
torch.tensor([0.0], device=tke.device), tke[2:-2, 2:-2, -1, taup1]
)
"""
add tendency due to lateral diffusion
"""
flux_east[:-1, :, :] = (
K_h_tke
* (tke[1:, :, :, tau] - tke[:-1, :, :, tau])
/ (cost[None, :, None] * dxu[:-1, None, None])
* maskU[:-1, :, :]
)
flux_east[-1, :, :] = 0.0
flux_north[:, :-1, :] = (
K_h_tke
* (tke[:, 1:, :, tau] - tke[:, :-1, :, tau])
/ dyu[None, :-1, None]
* maskV[:, :-1, :]
* cosu[None, :-1, None]
)
flux_north[:, -1, :] = 0.0
tke[2:-2, 2:-2, :, taup1] += (
dt_tke
* maskW[2:-2, 2:-2, :]
* (
(flux_east[2:-2, 2:-2, :] - flux_east[1:-3, 2:-2, :])
/ (cost[None, 2:-2, None] * dxt[2:-2, None, None])
+ (flux_north[2:-2, 2:-2, :] - flux_north[2:-2, 1:-3, :])
/ (cost[None, 2:-2, None] * dyt[None, 2:-2, None])
)
)
"""
add tendency due to advection
"""
adv_flux_superbee_wgrid(
flux_east,
flux_north,
flux_top,
tke[:, :, :, tau],
u[..., tau],
v[..., tau],
w[..., tau],
maskW,
dxt,
dyt,
dzw,
cost,
cosu,
dt_tracer,
)
dtke[2:-2, 2:-2, :, tau] = maskW[2:-2, 2:-2, :] * (
-(flux_east[2:-2, 2:-2, :] - flux_east[1:-3, 2:-2, :])
/ (cost[None, 2:-2, None] * dxt[2:-2, None, None])
- (flux_north[2:-2, 2:-2, :] - flux_north[2:-2, 1:-3, :])
/ (cost[None, 2:-2, None] * dyt[None, 2:-2, None])
)
dtke[:, :, 0, tau] += -flux_top[:, :, 0] / dzw[0]
dtke[:, :, 1:-1, tau] += -(flux_top[:, :, 1:-1] - flux_top[:, :, :-2]) / dzw[1:-1]
dtke[:, :, -1, tau] += -(flux_top[:, :, -1] - flux_top[:, :, -2]) / (0.5 * dzw[-1])
"""
Adam Bashforth time stepping
"""
tke[:, :, :, taup1] += dt_tracer * (
(1.5 + AB_eps) * dtke[:, :, :, tau] - (0.5 + AB_eps) * dtke[:, :, :, taum1]
)
return tke, dtke, tke_surf_corr
def prepare_inputs(*inputs, device):
out = [
torch.as_tensor(a, device=device) for a in inputs
]
if device == "gpu":
torch.cuda.synchronize()
return out
def run(*inputs, device="cpu"):
with torch.no_grad():
outputs = integrate_tke(*inputs)
if device == "gpu":
torch.cuda.synchronize()
return outputs
|
if __name__ == "__main__":
pass
|
from torchbenchmark.tasks import NLP
from torchbenchmark.util.framework.huggingface.model_factory import HuggingFaceModel
class Model(HuggingFaceModel):
task = NLP.LANGUAGE_MODELING
# Original train batch size per device: 8
# Source: https://github.com/huggingface/transformers/blob/master/examples/flax/language-modeling/run_t5_mlm_flax.py#L83
DEFAULT_TRAIN_BSIZE = 8
# Original eval batch size per device: 8
# Downscale to 1 to fit in Nvidia T4 of the infra
DEFAULT_EVAL_BSIZE = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(name="hf_T5", test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import subprocess
import sys
import os
from torchbenchmark.util.framework.huggingface.patch_hf import patch_transformers, cache_model
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
patch_transformers()
model_name = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
cache_model(model_name)
|
# Copyright (c) 2017 NVIDIA Corporation
import argparse
from math import sqrt
parser = argparse.ArgumentParser(description='RMSE_calculator')
parser.add_argument('--path_to_predictions', type=str, default="", metavar='N',
help='Path file with actual ratings and predictions')
parser.add_argument('--round', action='store_true',
help='round predictions to nearest')
args = parser.parse_args()
print(args)
def main():
with open(args.path_to_predictions, 'r') as inpt:
lines = inpt.readlines()
n = 0
denom = 0.0
for line in lines:
parts = line.split('\t')
prediction = float(parts[2]) if not args.round else round(float(parts[2]))
rating = float(parts[3])
denom += (prediction - rating)*(prediction - rating)
n += 1
print("####################")
print("RMSE: {}".format(sqrt(denom/n)))
print("####################")
if __name__ == '__main__':
main() |
# Benchmark created from NVidia DeepRecommender github project:
# https://github.com/NVIDIA/DeepRecommender
# a32a8a5c23092c551616acf6fac5b32e1155d18b
# Test supports eval and train modes for cpu and cuda targets.
#
# Both nvtrain.py and nvinfer.py support all original command
# line parameters but tensorflow dependency for logging has
# been removed.
import torch
from torchbenchmark.models.attention_is_all_you_need_pytorch.train import train
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import RECOMMENDATION
from typing import Tuple
import gc
from .nvtrain import DeepRecommenderTrainBenchmark
from .nvinfer import DeepRecommenderInferenceBenchmark
class Model(BenchmarkModel):
task = RECOMMENDATION.RECOMMENDATION
DEFAULT_TRAIN_BSIZE = 256
DEFAULT_EVAL_BSIZE = 256
def __init__(self, test, device, batch_size=None, jit=False, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.eval_mode = True if self.test == "eval" else False
if test == "train":
self.model = DeepRecommenderTrainBenchmark(device = self.device, jit = jit, batch_size=self.batch_size)
elif test == "eval":
self.model = DeepRecommenderInferenceBenchmark(device = self.device, jit = jit, batch_size=self.batch_size)
def jit_callback(self):
assert self.jit, "Calling JIT callback without specifying the JIT option."
self.model.rencoder = torch.jit.trace(self.model.rencoder, (self.model.toyinputs, ))
def get_module(self):
if self.eval_mode:
return self.model.rencoder, (self.model.toyinputs,)
return self.model.rencoder, (self.model.toyinputs,)
def set_module(self, new_model):
self.model.rencoder = new_model
def set_eval(self):
self.eval_mode = True
def set_train(self):
self.eval_mode = False
def get_optimizer(self):
return self.model.get_optimizer()
def set_optimizer(self, optimizer) -> None:
self.model.set_optimizer(optimizer)
def train(self):
self.model.train()
def eval(self) -> Tuple[torch.Tensor]:
out = self.model.eval()
return (out, )
def timed_infer(self):
self.model.TimedInferenceRun()
def timed_train(self):
self.model.TimedTrainingRun()
|
# Copyright (c) 2017 NVIDIA Corporation
# parameters to run benchmark on cpu
# --path_to_train_data Netflix/N1W_TRAIN --path_to_eval_data Netflix/N1W_TEST --hidden_layers 512,512,1024 --non_linearity_type selu --save_path model_save/model.epoch_0 --drop_prob 0.8 --predictions_path preds.txt --nooutput --forcecpu
# parameters to run benchmark on cuda
# --path_to_train_data Netflix/N1W_TRAIN --path_to_eval_data Netflix/N1W_TEST --hidden_layers 512,512,1024 --non_linearity_type selu --save_path model_save/model.epoch_0 --drop_prob 0.8 --predictions_path preds.txt --nooutput --forcecuda
import torch
import argparse
import copy
import time
import os
from .reco_encoder.data import input_layer
from .reco_encoder.model import model
from torch.autograd import Variable
from pathlib import Path
import torch.autograd.profiler as profiler
def getCommandLineArgs() :
parser = argparse.ArgumentParser(description='RecoEncoder')
parser.add_argument('--drop_prob', type=float, default=0.0, metavar='N',
help='dropout drop probability')
parser.add_argument('--constrained', action='store_true',
help='constrained autoencoder')
parser.add_argument('--skip_last_layer_nl', action='store_true',
help='if present, decoder\'s last layer will not apply non-linearity function')
parser.add_argument('--hidden_layers', type=str, default="1024,512,512,128", metavar='N',
help='hidden layer sizes, comma-separated')
parser.add_argument('--path_to_train_data', type=str, default="", metavar='N',
help='Path to training data')
parser.add_argument('--path_to_eval_data', type=str, default="", metavar='N',
help='Path to evaluation data')
parser.add_argument('--non_linearity_type', type=str, default="selu", metavar='N',
help='type of the non-linearity used in activations')
parser.add_argument('--save_path', type=str, default="autorec.pt", metavar='N',
help='where to save model')
parser.add_argument('--predictions_path', type=str, default="out.txt", metavar='N',
help='where to save predictions')
parser.add_argument('--batch_size', type=int, default=1, metavar='N',
help='inference batch size')
parser.add_argument('--jit', action='store_true',
help='jit-ify model before running')
parser.add_argument('--forcecuda', action='store_true',
help='force cuda use')
parser.add_argument('--forcecpu', action='store_true',
help='force cpu use')
parser.add_argument('--nooutput', action='store_true',
help='disable writing output to file')
parser.add_argument('--silent', action='store_true',
help='disable output messages')
parser.add_argument('--profile', action='store_true',
help='enable profiler and stat print')
args = parser.parse_args()
return args
def getBenchmarkArgs(forceCuda):
class Args:
pass
args = Args()
args.drop_prob = 0.8
args.constrained = False
args.skip_last_layer_nl = False
args.hidden_layers = '512,512,1024'
args.path_to_train_data = os.path.dirname(__file__) + '/Netflix/N1W_TRAIN'
args.path_to_eval_data = os.path.dirname(__file__) + '/Netflix/N1W_TEST'
args.non_linearity_type = 'selu'
args.save_path = 'model_save/model.epoch_0'
args.predictions_path = 'preds.txt'
args.batch_size = 1
args.jit = False
args.forcecuda = forceCuda
args.forcecpu = not forceCuda
args.nooutput = True
args.silent = True
args.profile = False
return args
def processArgState(args) :
if not args.silent:
print(args)
if args.forcecpu and args.forcecuda:
print("Error, force cpu and cuda cannot both be set")
quit()
args.use_cuda = torch.cuda.is_available() # global flag
if not args.silent:
if args.use_cuda:
print('GPU is available.')
else:
print('GPU is not available.')
if args.use_cuda and args.forcecpu:
args.use_cuda = False
if not args.silent:
if args.use_cuda:
print('Running On GPU')
else:
print('Running On CUDA')
if args.profile:
print('Profiler Enabled')
return args
class DeepRecommenderInferenceBenchmark:
def __init__(self, device = 'cpu', jit=False, batch_size=256, usecommandlineargs = False) :
self.toytest = True
self.batch_size = batch_size
# number of movies in netflix training set.
self.node_count = 197951
if self.toytest:
self.toyinputs = torch.randn(self.batch_size,self.node_count).to(device)
if usecommandlineargs:
self.args = getCommandLineArgs()
else:
if device == "cpu":
forcecuda = False
elif device == "cuda":
forcecuda = True
else:
# unknown device string, quit init
return
self.args = getBenchmarkArgs(forcecuda)
args = processArgState(self.args)
self.params = dict()
self.params['batch_size'] = self.args.batch_size
self.params['data_dir'] = self.args.path_to_train_data
self.params['major'] = 'users'
self.params['itemIdInd'] = 1
self.params['userIdInd'] = 0
if not self.args.silent:
print("Loading training data")
if self.toytest == False:
self.data_layer = input_layer.UserItemRecDataProvider(params=self.params)
if not self.args.silent:
print("Data loaded")
print("Total items found: {}".format(len(self.data_layer.data.keys())))
print("Vector dim: {}".format(self.data_layer.vector_dim))
print("Loading eval data")
self.eval_params = copy.deepcopy(self.params)
# must set eval batch size to 1 to make sure no examples are missed
self.eval_params['batch_size'] = 1
self.eval_params['data_dir'] = self.args.path_to_eval_data
if self.toytest:
self.rencoder = model.AutoEncoder(layer_sizes=[self.node_count] + [int(l) for l in self.args.hidden_layers.split(',')],
nl_type=self.args.non_linearity_type,
is_constrained=self.args.constrained,
dp_drop_prob=self.args.drop_prob,
last_layer_activations=not self.args.skip_last_layer_nl)
else:
self.eval_data_layer = input_layer.UserItemRecDataProvider(params=self.eval_params,
user_id_map=self.data_layer.userIdMap,
item_id_map=self.data_layer.itemIdMap)
self.rencoder = model.AutoEncoder(layer_sizes=[self.data_layer.vector_dim] + [int(l) for l in self.args.hidden_layers.split(',')],
nl_type=self.args.non_linearity_type,
is_constrained=self.args.constrained,
dp_drop_prob=self.args.drop_prob,
last_layer_activations=not self.args.skip_last_layer_nl)
self.path_to_model = Path(self.args.save_path)
if self.path_to_model.is_file():
print("Loading model from: {}".format(self.path_to_model))
self.rencoder.load_state_dict(torch.load(self.args.save_path))
if not self.args.silent:
print('######################################################')
print('######################################################')
print('############# AutoEncoder Model: #####################')
print(self.rencoder)
print('######################################################')
print('######################################################')
self.rencoder.eval()
if self.args.use_cuda: self.rencoder = self.rencoder.cuda()
if self.toytest == False:
self.inv_userIdMap = {v: k for k, v in self.data_layer.userIdMap.items()}
self.inv_itemIdMap = {v: k for k, v in self.data_layer.itemIdMap.items()}
self.eval_data_layer.src_data = self.data_layer.data
def eval(self, niter=1):
for iteration in range(niter):
if self.toytest:
out = self.rencoder(self.toyinputs)
continue
for i, ((out, src), majorInd) in enumerate(self.eval_data_layer.iterate_one_epoch_eval(for_inf=True)):
inputs = Variable(src.cuda().to_dense() if self.args.use_cuda else src.to_dense())
targets_np = out.to_dense().numpy()[0, :]
out = self.rencoder(inputs)
if not self.args.nooutput:
self.outputs = out.cpu().data.numpy()[0, :]
non_zeros = targets_np.nonzero()[0].tolist()
major_key = self.inv_userIdMap [majorInd]
with open(self.args.predictions_path, 'w') as outf:
for ind in non_zeros:
outf.write("{}\t{}\t{}\t{}\n".format(major_key, self.inv_itemIdMap[ind], self.outputs[ind], targets_np[ind]))
if i % 10000 == 0:
print("Done: {}".format(i))
return out
def TimedInferenceRun(self) :
print('Timed Inference Start')
e_start_time = time.time()
if self.args.profile:
with profiler.profile(record_shapes=True, use_cuda=True) as prof:
with profiler.record_function("Inference"):
self.eval()
else:
self.eval()
e_end_time = time.time()
print('Timed Inference Complete')
print('Inference finished in {} seconds'
.format(e_end_time - e_start_time))
if self.args.profile:
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
prof.export_chrome_trace("trace.json")
def main():
benchmarkCuda = DeepRecommenderInferenceBenchmark(device='cuda')
benchmarkCuda.TimedInferenceRun()
benchmarkCPU = DeepRecommenderInferenceBenchmark(device='cpu')
benchmarkCPU.TimedInferenceRun()
if __name__ == '__main__':
main()
|
# Copyright (c) 2017 NVIDIA Corporation
# to run against cuda:
# --gpu_ids 0 --path_to_train_data Netflix/N1W_TRAIN --path_to_eval_data Netflix/N1W_VALID --hidden_layers 512,512,1024 --non_linearity_type selu --batch_size 128 --logdir model_save --drop_prob 0.8 --optimizer momentum --lr 0.005 --weight_decay 0 --aug_step 1 --noise_prob 0 --num_epochs 1 --summary_frequency 1000 --forcecuda
# to run on cpu:
# --gpu_ids 0 --path_to_train_data Netflix/N1W_TRAIN --path_to_eval_data Netflix/N1W_VALID --hidden_layers 512,512,1024 --non_linearity_type selu --batch_size 128 --logdir model_save --drop_prob 0.8 --optimizer momentum --lr 0.005 --weight_decay 0 --aug_step 1 --noise_prob 0 --num_epochs 1 --summary_frequency 1000 --forcecpu
import torch
import argparse
from .reco_encoder.data import input_layer
from .reco_encoder.model import model
import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR
import torch.nn as nn
from torch.autograd import Variable
import copy
import time
from pathlib import Path
#from .logger import Logger
from math import sqrt
import numpy as np
import os
import torch.autograd.profiler as profiler
def getTrainBenchmarkArgs() :
class Args:
pass
args = Args()
args.lr = 0.005
args.weight_decay = 0
args.drop_prob = 0.8
args.noise_prob = 0
args.batch_size = 128
args.summary_frequency = 1000
args.aug_step = 1
args.constrained = False
args.skip_last_layer_nl = False
args.num_epochs = 1
args.save_every = 3
args.optimizer = 'momentum'
args.hidden_layers = '512,512,1024'
args.gpu_ids = '0'
args.path_to_train_data = os.path.dirname(__file__) + '/Netflix/N1W_TRAIN'
args.path_to_eval_data = os.path.dirname(__file__) + '/Netflix/N1W_VALID'
args.non_linearity_type = 'selu'
args.logdir = 'model_save'
args.nooutput = True
args.silent = True
args.forcecuda = False
args.forcecpu = False
args.profile = False
return args
def getTrainCommandLineArgs() :
parser = argparse.ArgumentParser(description='RecoEncoder')
parser.add_argument('--lr', type=float, default=0.00001, metavar='N',
help='learning rate')
parser.add_argument('--weight_decay', type=float, default=0.0, metavar='N',
help='L2 weight decay')
parser.add_argument('--drop_prob', type=float, default=0.0, metavar='N',
help='dropout drop probability')
parser.add_argument('--noise_prob', type=float, default=0.0, metavar='N',
help='noise probability')
parser.add_argument('--batch_size', type=int, default=64, metavar='N',
help='global batch size')
parser.add_argument('--summary_frequency', type=int, default=100, metavar='N',
help='how often to save summaries')
parser.add_argument('--aug_step', type=int, default=-1, metavar='N',
help='do data augmentation every X step')
parser.add_argument('--constrained', action='store_true',
help='constrained autoencoder')
parser.add_argument('--skip_last_layer_nl', action='store_true',
help='if present, decoder\'s last layer will not apply non-linearity function')
parser.add_argument('--num_epochs', type=int, default=50, metavar='N',
help='maximum number of epochs')
parser.add_argument('--save_every', type=int, default=3, metavar='N',
help='save every N number of epochs')
parser.add_argument('--optimizer', type=str, default="momentum", metavar='N',
help='optimizer kind: adam, momentum, adagrad or rmsprop')
parser.add_argument('--hidden_layers', type=str, default="1024,512,512,128", metavar='N',
help='hidden layer sizes, comma-separated')
parser.add_argument('--gpu_ids', type=str, default="0", metavar='N',
help='comma-separated gpu ids to use for data parallel training')
parser.add_argument('--path_to_train_data', type=str, default="", metavar='N',
help='Path to training data')
parser.add_argument('--path_to_eval_data', type=str, default="", metavar='N',
help='Path to evaluation data')
parser.add_argument('--non_linearity_type', type=str, default="selu", metavar='N',
help='type of the non-linearity used in activations')
parser.add_argument('--logdir', type=str, default="logs", metavar='N',
help='where to save model and write logs')
parser.add_argument('--nooutput', action='store_true',
help='disable writing output to file')
parser.add_argument('--silent', action='store_true',
help='disable all messages')
parser.add_argument('--forcecuda', action='store_true',
help='force cuda use')
parser.add_argument('--forcecpu', action='store_true',
help='force cpu use')
parser.add_argument('--profile', action='store_true',
help='enable profiler and stat print')
args = parser.parse_args()
return args
def processTrainArgState(args) :
if not args.silent:
print(args)
if args.forcecpu and args.forcecuda:
print("Error, force cpu and cuda cannot both be set")
quit()
args.use_cuda = torch.cuda.is_available() # global flag
if not args.silent:
if args.use_cuda:
print('GPU is available.')
else:
print('GPU is not available.')
if args.use_cuda and args.forcecpu:
args.use_cuda = False
if not args.silent:
if args.use_cuda:
print('Running On CUDA')
else:
print('Running On CPU')
return args
def log_var_and_grad_summaries(logger, layers, global_step, prefix, log_histograms=False):
"""
Logs variable and grad stats for layer. Transfers data from GPU to CPU automatically
:param logger: TB logger
:param layers: param list
:param global_step: global step for TB
:param prefix: name prefix
:param log_histograms: (default: False) whether or not log histograms
:return:
"""
for ind, w in enumerate(layers):
# Variables
w_var = w.data.cpu().numpy()
logger.scalar_summary("Variables/FrobNorm/{}_{}".format(prefix, ind), np.linalg.norm(w_var),
global_step)
if log_histograms:
logger.histo_summary(tag="Variables/{}_{}".format(prefix, ind), values=w.data.cpu().numpy(),
step=global_step)
# Gradients
w_grad = w.grad.data.cpu().numpy()
logger.scalar_summary("Gradients/FrobNorm/{}_{}".format(prefix, ind), np.linalg.norm(w_grad),
global_step)
if log_histograms:
logger.histo_summary(tag="Gradients/{}_{}".format(prefix, ind), values=w.grad.data.cpu().numpy(),
step=global_step)
def DoTrainEval(encoder, evaluation_data_layer, use_cuda):
encoder.eval()
denom = 0.0
total_epoch_loss = 0.0
for i, (eval, src) in enumerate(evaluation_data_layer.iterate_one_epoch_eval()):
inputs = Variable(src.cuda().to_dense() if use_cuda else src.to_dense())
targets = Variable(eval.cuda().to_dense() if use_cuda else eval.to_dense())
outputs = encoder(inputs)
loss, num_ratings = model.MSEloss(outputs, targets)
total_epoch_loss += loss.item()
denom += num_ratings.item()
return sqrt(total_epoch_loss / denom)
class DeepRecommenderTrainBenchmark:
def __init__(self, device="cpu", jit=False, batch_size=256, processCommandLine = False):
self.TrainInit(device, jit, batch_size, processCommandLine)
def TrainInit(self, device="cpu", jit=False, batch_size=256, processCommandLine = False):
# Force test to run in toy mode. Single call of fake data to model.
self.toytest = True
self.toybatch = batch_size
# number of movies in netflix training set.
self.toyvocab = 197951
self.toyinputs = torch.randn(self.toybatch, self.toyvocab)
if (processCommandLine) :
self.args = getTrainCommandLineArgs()
else:
self.args = getTrainBenchmarkArgs()
if device == "cpu":
forcecuda = False
elif device == "cuda":
forcecuda = True
else:
# unknown device string, quit init
return
self.args.forcecuda = forcecuda
self.args.forcecpu = not forcecuda
self.args = processTrainArgState(self.args)
if self.toytest == False:
self.logger = Logger(self.args.logdir)
self.params = dict()
self.params['batch_size'] = self.args.batch_size
self.params['data_dir'] = self.args.path_to_train_data
self.params['major'] = 'users'
self.params['itemIdInd'] = 1
self.params['userIdInd'] = 0
if self.toytest == False:
if not self.args.silent:
print("Loading training data")
self.data_layer = input_layer.UserItemRecDataProvider(params=self.params)
if not self.args.silent:
print("Data loaded")
print("Total items found: {}".format(len(self.data_layer.data.keys())))
print("Vector dim: {}".format(self.data_layer.vector_dim))
print("Loading eval data")
self.eval_params = copy.deepcopy(self.params)
# must set eval batch size to 1 to make sure no examples are missed
if self.toytest:
self.rencoder = model.AutoEncoder(layer_sizes=[self.toyvocab] + [int(l) for l in self.args.hidden_layers.split(',')],
nl_type=self.args.non_linearity_type,
is_constrained=self.args.constrained,
dp_drop_prob=self.args.drop_prob,
last_layer_activations=not self.args.skip_last_layer_nl)
else:
self.eval_params['data_dir'] = self.args.path_to_eval_data
self.eval_data_layer = input_layer.UserItemRecDataProvider(params=self.eval_params,
user_id_map=self.data_layer.userIdMap, # the mappings are provided
item_id_map=self.data_layer.itemIdMap)
self.eval_data_layer.src_data = self.data_layer.data
self.rencoder = model.AutoEncoder(layer_sizes=[self.data_layer.vector_dim] + [int(l) for l in self.args.hidden_layers.split(',')],
nl_type=self.args.non_linearity_type,
is_constrained=self.args.constrained,
dp_drop_prob=self.args.drop_prob,
last_layer_activations=not self.args.skip_last_layer_nl)
os.makedirs(self.args.logdir, exist_ok=True)
self.model_checkpoint = self.args.logdir + "/model"
self.path_to_model = Path(self.model_checkpoint)
if self.path_to_model.is_file():
print("Loading model from: {}".format(self.model_checkpoint))
self.rencoder.load_state_dict(torch.load(self.model_checkpoint))
if not self.args.silent:
print('######################################################')
print('######################################################')
print('############# AutoEncoder Model: #####################')
print(self.rencoder)
print('######################################################')
print('######################################################')
if self.args.use_cuda:
gpu_ids = [int(g) for g in self.args.gpu_ids.split(',')]
if not self.args.silent:
print('Using GPUs: {}'.format(gpu_ids))
if len(gpu_ids)>1:
self.rencoder = nn.DataParallel(self.rencoder,
device_ids=gpu_ids)
self.rencoder = self.rencoder.cuda()
self.toyinputs = self.toyinputs.to(device)
if self.args.optimizer == "adam":
self.optimizer = optim.Adam(self.rencoder.parameters(),
lr=self.args.lr,
weight_decay=self.args.weight_decay)
elif self.args.optimizer == "adagrad":
self.optimizer = optim.Adagrad(self.rencoder.parameters(),
lr=self.args.lr,
weight_decay=self.args.weight_decay)
elif self.args.optimizer == "momentum":
self.optimizer = optim.SGD(self.rencoder.parameters(),
lr=self.args.lr, momentum=0.9,
weight_decay=self.args.weight_decay)
self.scheduler = MultiStepLR(self.optimizer, milestones=[24, 36, 48, 66, 72], gamma=0.5)
elif args.optimizer == "rmsprop":
self.optimizer = optim.RMSprop(self.rencoder.parameters(),
lr=self.args.lr, momentum=0.9,
weight_decay=self.args.weight_decay)
else:
raise ValueError('Unknown optimizer kind')
self.t_loss = 0.0
self.t_loss_denom = 0.0
self.denom = 0.0
self.total_epoch_loss = 0.0
self.global_step = 0
if self.args.noise_prob > 0.0:
self.dp = nn.Dropout(p=self.args.noise_prob)
def get_optimizer(self):
return self.optimizer
def set_optimizer(self, optimizer):
self.optimizer = optimizer
def DoTrain(self):
self.rencoder.train()
#if self.args.optimizer == "momentum":
# self.scheduler.step()
for i, mb in enumerate(self.data_layer.iterate_one_epoch()):
inputs = Variable(mb.cuda().to_dense() if self.args.use_cuda else mb.to_dense())
self.optimizer.zero_grad()
outputs = self.rencoder(inputs)
loss, num_ratings = model.MSEloss(outputs, inputs)
loss = loss / num_ratings
loss.backward()
self.optimizer.step()
self.global_step += 1
self.t_loss += loss.item()
self.t_loss_denom += 1
if not self.args.nooutput:
if i % self.args.summary_frequency == 0:
print('[%d, %5d] RMSE: %.7f' % (self.epoch, i, sqrt(self.t_loss / self.t_loss_denom)))
self.logger.scalar_summary("Training_RMSE", sqrt(self.t_loss/self.t_loss_denom), self.global_step)
self.t_loss = 0
self.t_loss_denom = 0.0
log_var_and_grad_summaries(self.logger, self.rencoder.encode_w, self.global_step, "Encode_W")
log_var_and_grad_summaries(self.logger, self.rencoder.encode_b, self.global_step, "Encode_b")
if not self.rencoder.is_constrained:
log_var_and_grad_summaries(self.logger, self.rencoder.decode_w, self.global_step, "Decode_W")
log_var_and_grad_summaries(self.logger, self.rencoder.decode_b, self.global_step, "Decode_b")
self.total_epoch_loss += loss.item()
self.denom += 1
#if args.aug_step > 0 and i % args.aug_step == 0 and i > 0:
if self.args.aug_step > 0:
# Magic data augmentation trick happen here
for t in range(self.args.aug_step):
inputs = Variable(outputs.data)
if self.args.noise_prob > 0.0:
inputs = dp(inputs)
self.optimizer.zero_grad()
outputs = self.rencoder(inputs)
loss, num_ratings = model.MSEloss(outputs, inputs)
loss = loss / num_ratings
loss.backward()
self.optimizer.step()
def train(self, niter=1) :
for self.epoch in range(niter):
if self.toytest:
self.rencoder.train()
self.optimizer.zero_grad()
outputs = self.rencoder(self.toyinputs)
loss, num_ratings = model.MSEloss(outputs, self.toyinputs)
loss = loss / num_ratings
loss.backward()
self.optimizer.step()
continue
if not self.args.silent:
print('Doing epoch {} of {}'.format(self.epoch, niter))
print('Timing Start')
e_start_time = time.time()
self.DoTrain()
if not self.args.silent:
e_end_time = time.time()
print('Timing End')
if self.args.profile:
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
prof.export_chrome_trace("trace.json")
print('Total epoch {} finished in {} seconds with TRAINING RMSE loss: {}'
.format(self.epoch, e_end_time - e_start_time, sqrt(self.total_epoch_loss/self.denom)))
if not self.args.silent:
self.logger.scalar_summary("Training_RMSE_per_epoch", sqrt(self.total_epoch_loss/self.denom), self.epoch)
self.logger.scalar_summary("Epoch_time", e_end_time - e_start_time, self.epoch)
if self.epoch % self.args.save_every == 0 or self.epoch == self.args.num_epochs - 1:
eval_loss = DoTrainEval(self.rencoder, self.eval_data_layer, self.args.use_cuda)
print('Epoch {} EVALUATION LOSS: {}'.format(self.epoch, eval_loss))
self.logger.scalar_summary("EVALUATION_RMSE", eval_loss, self.epoch)
print("Saving model to {}".format(self.model_checkpoint + ".epoch_"+str(self.epoch)))
torch.save(self.rencoder.state_dict(), self.model_checkpoint + ".epoch_"+str(self.epoch))
if not self.args.nooutput:
print("Saving model to {}".format(self.model_checkpoint + ".last"))
torch.save(self.rencoder.state_dict(), self.model_checkpoint + ".last")
# save to onnx
dummy_input = Variable(torch.randn(self.params['batch_size'], self.data_layer.vector_dim).type(torch.float))
torch.onnx.export(self.rencoder.float(), dummy_input.cuda() if self.args.use_cuda else dummy_input,
self.model_checkpoint + ".onnx", verbose=True)
print("ONNX model saved to {}!".format(self.model_checkpoint + ".onnx"))
def TimedTrainingRun(self):
if self.args.profile:
with profiler.profile(record_shapes=True, use_cuda=self.args.use_cuda) as prof:
with profiler.record_function("training_epoch"):
self.train(self.args.num_epochs)
else:
self.train(self.args.num_epochs)
def main() :
gpuTrain = DeepRecommenderTrainBenchmark(device = 'cuda')
gpuTrain.TimedTrainingRun()
gpuTrain = DeepRecommenderBenchmark(device = 'cpu')
gpuTrain.TimedTrainingRun()
if __name__ == '__main__':
main()
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
# Copyright (c) 2017 NVIDIA Corporation
from os import listdir, path, makedirs
import random
import sys
import time
import datetime
def print_stats(data):
total_ratings = 0
print("STATS")
for user in data:
total_ratings += len(data[user])
print("Total Ratings: {}".format(total_ratings))
print("Total User count: {}".format(len(data.keys())))
def save_data_to_file(data, filename):
with open(filename, 'w') as out:
for userId in data:
for record in data[userId]:
out.write("{}\t{}\t{}\n".format(userId, record[0], record[1]))
def create_NETFLIX_data_timesplit(all_data,
train_min,
train_max,
test_min,
test_max):
"""
Creates time-based split of NETFLIX data into train, and (validation, test)
:param all_data:
:param train_min:
:param train_max:
:param test_min:
:param test_max:
:return:
"""
train_min_ts = time.mktime(datetime.datetime.strptime(train_min,"%Y-%m-%d").timetuple())
train_max_ts = time.mktime(datetime.datetime.strptime(train_max, "%Y-%m-%d").timetuple())
test_min_ts = time.mktime(datetime.datetime.strptime(test_min, "%Y-%m-%d").timetuple())
test_max_ts = time.mktime(datetime.datetime.strptime(test_max, "%Y-%m-%d").timetuple())
training_data = dict()
validation_data = dict()
test_data = dict()
train_set_items = set()
for userId, userRatings in all_data.items():
time_sorted_ratings = sorted(userRatings, key=lambda x: x[2]) # sort by timestamp
for rating_item in time_sorted_ratings:
if rating_item[2] >= train_min_ts and rating_item[2] <= train_max_ts:
if not userId in training_data:
training_data[userId] = []
training_data[userId].append(rating_item)
train_set_items.add(rating_item[0]) # keep track of items from training set
elif rating_item[2] >= test_min_ts and rating_item[2] <= test_max_ts:
if not userId in training_data: # only include users seen in the training set
continue
p = random.random()
if p <=0.5:
if not userId in validation_data:
validation_data[userId] = []
validation_data[userId].append(rating_item)
else:
if not userId in test_data:
test_data[userId] = []
test_data[userId].append(rating_item)
# remove items not not seen in training set
for userId, userRatings in test_data.items():
test_data[userId] = [rating for rating in userRatings if rating[0] in train_set_items]
for userId, userRatings in validation_data.items():
validation_data[userId] = [rating for rating in userRatings if rating[0] in train_set_items]
return training_data, validation_data, test_data
def main(args):
user2id_map = dict()
item2id_map = dict()
userId = 0
itemId = 0
all_data = dict()
folder = args[1]
out_folder = args[2]
# create necessary folders:
for output_dir in [(out_folder + f) for f in [
"/N1W_TRAIN", "/N1W_VALID", "/N1W_TEST",
"/N3M_TRAIN", "/N3M_VALID", "/N3M_TEST",
"/N6M_TRAIN", "/N6M_VALID", "/N6M_TEST",
"/N1Y_TRAIN", "/N1Y_VALID", "/N1Y_TEST",
"/NF_TRAIN", "/NF_VALID", "/NF_TEST"]]:
makedirs(output_dir, exist_ok=True)
text_files = [path.join(folder, f)
for f in listdir(folder)
if path.isfile(path.join(folder, f)) and ('.txt' in f)]
for text_file in text_files:
with open(text_file, 'r') as f:
print("Processing: {}".format(text_file))
lines = f.readlines()
item = int(lines[0][:-2]) # remove newline and :
if not item in item2id_map:
item2id_map[item] = itemId
itemId += 1
for rating in lines[1:]:
parts = rating.strip().split(",")
user = int(parts[0])
if not user in user2id_map:
user2id_map[user] = userId
userId += 1
rating = float(parts[1])
ts = int(time.mktime(datetime.datetime.strptime(parts[2],"%Y-%m-%d").timetuple()))
if user2id_map[user] not in all_data:
all_data[user2id_map[user]] = []
all_data[user2id_map[user]].append((item2id_map[item], rating, ts))
print("STATS FOR ALL INPUT DATA")
print_stats(all_data)
# Netflix 1 week, for benchmark
(n1w_train, n1w_valid, n1w_test) = create_NETFLIX_data_timesplit(all_data,
"2005-09-01",
"2005-09-07",
"2005-09-10",
"2005-09-11")
print("Netflix 1w train")
print_stats(n1w_train)
save_data_to_file(n1w_train, out_folder+"/N1W_TRAIN/n1w.train.txt")
print("Netflix 1w valid")
print_stats(n1w_valid)
save_data_to_file(n1w_valid, out_folder + "/N1W_VALID/n1w.valid.txt")
print("Netflix 1w test")
print_stats(n1w_test)
save_data_to_file(n1w_test, out_folder + "/N1W_TEST/n1w.test.txt")
print("finished 1 week!")
quit()
# Netflix full
(nf_train, nf_valid, nf_test) = create_NETFLIX_data_timesplit(all_data,
"1999-12-01",
"2005-11-30",
"2005-12-01",
"2005-12-31")
print("Netflix full train")
print_stats(nf_train)
save_data_to_file(nf_train, out_folder + "/NF_TRAIN/nf.train.txt")
print("Netflix full valid")
print_stats(nf_valid)
save_data_to_file(nf_valid, out_folder + "/NF_VALID/nf.valid.txt")
print("Netflix full test")
print_stats(nf_test)
save_data_to_file(nf_test, out_folder + "/NF_TEST/nf.test.txt")
(n3m_train, n3m_valid, n3m_test) = create_NETFLIX_data_timesplit(all_data,
"2005-09-01",
"2005-11-30",
"2005-12-01",
"2005-12-31")
print("Netflix 3m train")
print_stats(n3m_train)
save_data_to_file(n3m_train, out_folder+"/N3M_TRAIN/n3m.train.txt")
print("Netflix 3m valid")
print_stats(n3m_valid)
save_data_to_file(n3m_valid, out_folder + "/N3M_VALID/n3m.valid.txt")
print("Netflix 3m test")
print_stats(n3m_test)
save_data_to_file(n3m_test, out_folder + "/N3M_TEST/n3m.test.txt")
(n6m_train, n6m_valid, n6m_test) = create_NETFLIX_data_timesplit(all_data,
"2005-06-01",
"2005-11-30",
"2005-12-01",
"2005-12-31")
print("Netflix 6m train")
print_stats(n6m_train)
save_data_to_file(n6m_train, out_folder+"/N6M_TRAIN/n6m.train.txt")
print("Netflix 6m valid")
print_stats(n6m_valid)
save_data_to_file(n6m_valid, out_folder + "/N6M_VALID/n6m.valid.txt")
print("Netflix 6m test")
print_stats(n6m_test)
save_data_to_file(n6m_test, out_folder + "/N6M_TEST/n6m.test.txt")
# Netflix 1 year
(n1y_train, n1y_valid, n1y_test) = create_NETFLIX_data_timesplit(all_data,
"2004-06-01",
"2005-05-31",
"2005-06-01",
"2005-06-30")
print("Netflix 1y train")
print_stats(n1y_train)
save_data_to_file(n1y_train, out_folder + "/N1Y_TRAIN/n1y.train.txt")
print("Netflix 1y valid")
print_stats(n1y_valid)
save_data_to_file(n1y_valid, out_folder + "/N1Y_VALID/n1y.valid.txt")
print("Netflix 1y test")
print_stats(n1y_test)
save_data_to_file(n1y_test, out_folder + "/N1Y_TEST/n1y.test.txt")
if __name__ == "__main__":
main(sys.argv)
|
# Copyright (c) 2017 NVIDIA Corporation
import sys
import datetime
import random
from math import floor
def print_stats(data):
total_ratings = 0
print("STATS")
for user in data:
total_ratings += len(data[user])
print("Total Ratings: {}".format(total_ratings))
print("Total User count: {}".format(len(data.keys())))
def save_data_to_file(data, filename):
with open(filename, 'w') as out:
for userId in data:
for record in data[userId]:
out.write("{}\t{}\t{}\n".format(userId, record[0], record[1]))
def main(args):
inpt = args[1]
out_prefix = args[2]
percent = 0.7
user2id_map = dict()
item2id_map = dict()
userId = 0
itemId = 0
data = dict()
min_ts = 100000000000
max_ts = 0
total_rating_count = 0
with open(inpt, 'r') as inpt_f: #ratings.csv headers: userId,movieId,rating,timestamp
for line in inpt_f:
if 'userId' in line:
continue
parts = line.split(',')
user = int(parts[0])
item = int(parts[1])
rating = float(parts[2])
ts = int(parts[3])
if min_ts > ts:
min_ts = ts
if max_ts < ts:
max_ts = ts
if not user in user2id_map:
user2id_map[user] = userId
userId += 1
if not item in item2id_map:
item2id_map[item] = itemId
itemId += 1
total_rating_count += 1
if user2id_map[user] not in data:
data[user2id_map[user]] = []
data[user2id_map[user]].append((item2id_map[item], rating, ts))
print("STATS")
print("Total Ratings: {}".format(total_rating_count))
print("Total User count: {}".format(len(user2id_map)))
print("Total Item count: {}".format(len(item2id_map)))
print("Minimum ts: {}, which is {}".format(min_ts, datetime.datetime.fromtimestamp(min_ts).strftime('%Y-%m-%d')))
print("Maximum ts: {}, which is {}".format(max_ts, datetime.datetime.fromtimestamp(max_ts).strftime('%Y-%m-%d')))
training_data = dict()
validation_data = dict()
test_data = dict()
train_set_items = set()
for userId in data.keys():
if len(data[userId]) < 2:
#print("WARNING, userId {} has less than 2 ratings, skipping user...".format(userId))
continue
time_sorted_ratings = sorted(data[userId], key=lambda x: x[2]) # sort by timestamp
last_train_ind = floor(percent * len(time_sorted_ratings))
training_data[userId] = time_sorted_ratings[:last_train_ind]
for rating_item in time_sorted_ratings[:last_train_ind]:
train_set_items.add(rating_item[0]) # keep track of items from training set
p = random.random()
if p <= 0.5:
validation_data[userId] = time_sorted_ratings[last_train_ind:]
else:
test_data[userId] = time_sorted_ratings[last_train_ind:]
# remove items not not seen in training set
for userId, userRatings in test_data.items():
test_data[userId] = [rating for rating in userRatings if rating[0] in train_set_items]
for userId, userRatings in validation_data.items():
validation_data[userId] = [rating for rating in userRatings if rating[0] in train_set_items]
print("Training Data")
print_stats(training_data)
save_data_to_file(training_data, out_prefix+".train")
print("Validation Data")
print_stats(validation_data)
save_data_to_file(validation_data, out_prefix + ".valid")
print("Test Data")
print_stats(test_data)
save_data_to_file(test_data, out_prefix + ".test")
if __name__ == "__main__":
main(sys.argv)
|
# Copyright (c) 2017 NVIDIA Corporation
|
# Copyright (c) 2017 NVIDIA Corporation
|
# Copyright (c) 2017 NVIDIA Corporation
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as weight_init
from torch.autograd import Variable
def activation(input, kind):
#print("Activation: {}".format(kind))
if kind == 'selu':
return F.selu(input)
elif kind == 'relu':
return F.relu(input)
elif kind == 'relu6':
return F.relu6(input)
elif kind == 'sigmoid':
return F.sigmoid(input)
elif kind == 'tanh':
return F.tanh(input)
elif kind == 'elu':
return F.elu(input)
elif kind == 'lrelu':
return F.leaky_relu(input)
elif kind == 'swish':
return input*F.sigmoid(input)
elif kind == 'none':
return input
else:
raise ValueError('Unknown non-linearity type')
def MSEloss(inputs, targets, size_average=False):
mask = targets != 0
num_ratings = torch.sum(mask.float())
criterion = nn.MSELoss(reduction='sum' if not size_average else 'mean')
return criterion(inputs * mask.float(), targets), Variable(torch.Tensor([1.0])) if size_average else num_ratings
class AutoEncoder(nn.Module):
def __init__(self, layer_sizes, nl_type='selu', is_constrained=True, dp_drop_prob=0.0, last_layer_activations=True):
"""
Describes an AutoEncoder model
:param layer_sizes: Encoder network description. Should start with feature size (e.g. dimensionality of x).
For example: [10000, 1024, 512] will result in:
- encoder 2 layers: 10000x1024 and 1024x512. Representation layer (z) will be 512
- decoder 2 layers: 512x1024 and 1024x10000.
:param nl_type: (default 'selu') Type of no-linearity
:param is_constrained: (default: True) Should constrain decoder weights
:param dp_drop_prob: (default: 0.0) Dropout drop probability
:param last_layer_activations: (default: True) Whether to apply activations on last decoder layer
"""
super(AutoEncoder, self).__init__()
self._dp_drop_prob = dp_drop_prob
self._last_layer_activations = last_layer_activations
if dp_drop_prob > 0:
self.drop = nn.Dropout(dp_drop_prob)
self._last = len(layer_sizes) - 2
self._nl_type = nl_type
self.encode_w = nn.ParameterList(
[nn.Parameter(torch.rand(layer_sizes[i + 1], layer_sizes[i])) for i in range(len(layer_sizes) - 1)])
for ind, w in enumerate(self.encode_w):
weight_init.xavier_uniform_(w)
self.encode_b = nn.ParameterList(
[nn.Parameter(torch.zeros(layer_sizes[i + 1])) for i in range(len(layer_sizes) - 1)])
reversed_enc_layers = list(reversed(layer_sizes))
self.is_constrained = is_constrained
if not is_constrained:
self.decode_w = nn.ParameterList(
[nn.Parameter(torch.rand(reversed_enc_layers[i + 1], reversed_enc_layers[i])) for i in range(len(reversed_enc_layers) - 1)])
for ind, w in enumerate(self.decode_w):
nn.init.xavier_uniform_(w)
self.decode_b = nn.ParameterList(
[nn.Parameter(torch.zeros(reversed_enc_layers[i + 1])) for i in range(len(reversed_enc_layers) - 1)])
if False:
print("******************************")
print("******************************")
print(layer_sizes)
print("Dropout drop probability: {}".format(self._dp_drop_prob))
print("Encoder pass:")
for ind, w in enumerate(self.encode_w):
print(w.data.size())
print(self.encode_b[ind].size())
print("Decoder pass:")
if self.is_constrained:
print('Decoder is constrained')
for ind, w in enumerate(list(reversed(self.encode_w))):
print(w.transpose(0, 1).size())
print(self.decode_b[ind].size())
else:
for ind, w in enumerate(self.decode_w):
print(w.data.size())
print(self.decode_b[ind].size())
print("******************************")
print("******************************")
def encode(self, x):
for ind, w in enumerate(self.encode_w):
x = activation(input=F.linear(input=x, weight=w, bias=self.encode_b[ind]), kind=self._nl_type)
if self._dp_drop_prob > 0: # apply dropout only on code layer
x = self.drop(x)
return x
def decode(self, z):
if False: #self.is_constrained:
for ind, w in enumerate(list(reversed(self.encode_w))): # constrained autoencode re-uses weights from encoder
z = activation(input=F.linear(input=z, weight=w.transpose(0, 1), bias=self.decode_b[ind]),
# last layer or decoder should not apply non linearities
kind=self._nl_type if ind!=self._last or self._last_layer_activations else 'none')
#if self._dp_drop_prob > 0 and ind!=self._last: # and no dp on last layer
# z = self.drop(z)
else:
for ind, w in enumerate(self.decode_w):
z = activation(input=F.linear(input=z, weight=w, bias=self.decode_b[ind]),
# last layer or decoder should not apply non linearities
kind=self._nl_type if ind!=self._last or self._last_layer_activations else 'none')
#if self._dp_drop_prob > 0 and ind!=self._last: # and no dp on last layer
# z = self.drop(z)
return z
def forward(self, x):
return self.decode(self.encode(x))
|
# Copyright (c) 2017 NVIDIA Corporation
|
# Copyright (c) 2017 NVIDIA Corporation
"""Data Layer Classes"""
from os import listdir, path
from random import shuffle
import torch
class UserItemRecDataProvider:
def __init__(self, params, user_id_map=None, item_id_map=None):
self._params = params
self._data_dir = self.params['data_dir']
self._extension = ".txt" if 'extension' not in self.params else self.params['extension']
self._i_id = 0 if 'itemIdInd' not in self.params else self.params['itemIdInd']
self._u_id = 1 if 'userIdInd' not in self.params else self.params['userIdInd']
self._r_id = 2 if 'ratingInd' not in self.params else self.params['ratingInd']
self._major = 'items' if 'major' not in self.params else self.params['major']
if not (self._major == 'items' or self._major == 'users'):
raise ValueError("Major must be 'users' or 'items', but got {}".format(self._major))
self._major_ind = self._i_id if self._major == 'items' else self._u_id
self._minor_ind = self._u_id if self._major == 'items' else self._i_id
self._delimiter = '\t' if 'delimiter' not in self.params else self.params['delimiter']
if user_id_map is None or item_id_map is None:
self._build_maps()
else:
self._user_id_map = user_id_map
self._item_id_map = item_id_map
major_map = self._item_id_map if self._major == 'items' else self._user_id_map
minor_map = self._user_id_map if self._major == 'items' else self._item_id_map
self._vector_dim = len(minor_map)
src_files = [path.join(self._data_dir, f)
for f in listdir(self._data_dir)
if path.isfile(path.join(self._data_dir, f)) and f.endswith(self._extension)]
self._batch_size = self.params['batch_size']
self.data = dict()
for source_file in src_files:
with open(source_file, 'r') as src:
for line in src.readlines():
parts = line.strip().split(self._delimiter)
if len(parts)<3:
raise ValueError('Encountered badly formatted line in {}'.format(source_file))
key = major_map[int(parts[self._major_ind])]
value = minor_map[int(parts[self._minor_ind])]
rating = float(parts[self._r_id])
#print("Key: {}, Value: {}, Rating: {}".format(key, value, rating))
if key not in self.data:
self.data[key] = []
self.data[key].append((value, rating))
def _build_maps(self):
self._user_id_map = dict()
self._item_id_map = dict()
src_files = [path.join(self._data_dir, f)
for f in listdir(self._data_dir)
if path.isfile(path.join(self._data_dir, f)) and f.endswith(self._extension)]
u_id = 0
i_id = 0
for source_file in src_files:
with open(source_file, 'r') as src:
for line in src.readlines():
parts = line.strip().split(self._delimiter)
if len(parts)<3:
raise ValueError('Encountered badly formatted line in {}'.format(source_file))
u_id_orig = int(parts[self._u_id])
if u_id_orig not in self._user_id_map:
self._user_id_map[u_id_orig] = u_id
u_id += 1
i_id_orig = int(parts[self._i_id])
if i_id_orig not in self._item_id_map:
self._item_id_map[i_id_orig] = i_id
i_id += 1
def iterate_one_epoch(self):
data = self.data
keys = list(data.keys())
shuffle(keys)
s_ind = 0
e_ind = self._batch_size
while e_ind < len(keys):
local_ind = 0
inds1 = []
inds2 = []
vals = []
for ind in range(s_ind, e_ind):
inds2 += [v[0] for v in data[keys[ind]]]
inds1 += [local_ind]*len([v[0] for v in data[keys[ind]]])
vals += [v[1] for v in data[keys[ind]]]
local_ind += 1
i_torch = torch.LongTensor([inds1, inds2])
v_torch = torch.FloatTensor(vals)
mini_batch = torch.sparse.FloatTensor(i_torch, v_torch, torch.Size([self._batch_size, self._vector_dim]))
s_ind += self._batch_size
e_ind += self._batch_size
yield mini_batch
def iterate_one_epoch_eval(self, for_inf=False):
keys = list(self.data.keys())
s_ind = 0
while s_ind < len(keys):
inds1 = [0] * len([v[0] for v in self.data[keys[s_ind]]])
inds2 = [v[0] for v in self.data[keys[s_ind]]]
vals = [v[1] for v in self.data[keys[s_ind]]]
src_inds1 = [0] * len([v[0] for v in self.src_data[keys[s_ind]]])
src_inds2 = [v[0] for v in self.src_data[keys[s_ind]]]
src_vals = [v[1] for v in self.src_data[keys[s_ind]]]
i_torch = torch.LongTensor([inds1, inds2])
v_torch = torch.FloatTensor(vals)
src_i_torch = torch.LongTensor([src_inds1, src_inds2])
src_v_torch = torch.FloatTensor(src_vals)
mini_batch = (torch.sparse.FloatTensor(i_torch, v_torch, torch.Size([1, self._vector_dim])),
torch.sparse.FloatTensor(src_i_torch, src_v_torch, torch.Size([1, self._vector_dim])))
s_ind += 1
if not for_inf:
yield mini_batch
else:
yield mini_batch, keys[s_ind - 1]
@property
def vector_dim(self):
return self._vector_dim
@property
def userIdMap(self):
return self._user_id_map
@property
def itemIdMap(self):
return self._item_id_map
@property
def params(self):
return self._params
|
import os
from torchbenchmark.tasks import COMPUTER_VISION
from torchbenchmark.util.framework.detectron2.model_factory import Detectron2Model
MODEL_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
class Model(Detectron2Model):
task = COMPUTER_VISION.SEGMENTATION
model_file = os.path.join(MODEL_DIR, ".data", f"{MODEL_NAME}.pkl")
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(variant="COCO-InstanceSegmentation/mask_rcnn_R_101_FPN_3x.yaml", test=test, device=device,
jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import os
from torchbenchmark.util.framework.detectron2 import install_detectron2
MODEL_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
if __name__ == '__main__':
install_detectron2(MODEL_NAME, MODEL_DIR)
|
import torch
import torch.optim as optim
import torch.nn as nn
import torch.utils.data as data
import torchvision.models as models
from opacus import PrivacyEngine
from opacus.validators.module_validator import ModuleValidator
from typing import Tuple
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import OTHER
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
DEFAULT_TRAIN_BSIZE = 64
DEFAULT_EVAL_BSIZE = 64
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
# disable torchdynamo-fx2trt because it never terminates
if "--torchdynamo" in extra_args and "fx2trt" in extra_args:
raise NotImplementedError("TorchDynamo Fx2trt is not supported because of hanging issue. "
"See: https://github.com/facebookresearch/torchdynamo/issues/109")
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = models.resnet18(num_classes=10)
self.model = ModuleValidator.fix(self.model)
self.model = self.model.to(device)
# Cifar10 images are 32x32 and have 10 classes
self.example_inputs = (
torch.randn((self.batch_size, 3, 32, 32), device=self.device),
)
self.example_target = torch.randint(0, 10, (self.batch_size,), device=self.device)
dataset = data.TensorDataset(self.example_inputs[0], self.example_target)
self.dummy_loader = data.DataLoader(dataset, batch_size=self.batch_size)
self.noise_multiplier: float=1.0
self.max_grad_norm: float=1.0
self.poisson_sampling: bool=False
self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)
self.criterion = nn.CrossEntropyLoss()
self.privacy_engine = PrivacyEngine()
self.model, self.optimizer, _ = self.privacy_engine.make_private(
module=self.model,
optimizer=self.optimizer,
data_loader=self.dummy_loader,
noise_multiplier=self.noise_multiplier,
max_grad_norm=self.max_grad_norm,
poisson_sampling=self.poisson_sampling,
)
def get_module(self):
return self.model, self.example_inputs
def get_optimizer(self):
return self.optimizer
def set_optimizer(self, optimizer) -> None:
self.optimizer = optimizer
self.model, self.optimizer, _ = self.privacy_engine.make_private(
module=self.model,
optimizer=self.optimizer,
data_loader=self.dummy_loader,
noise_multiplier=1.0,
max_grad_norm=1.0,
poisson_sampling=False,
)
def train(self):
model = self.model
(images, ) = self.example_inputs
model.train()
targets = self.example_target
output = model(images)
loss = self.criterion(output, targets)
loss.backward()
self.optimizer.step()
self.optimizer.zero_grad()
def eval(self) -> Tuple[torch.Tensor]:
model = self.model
(images, ) = self.example_inputs
model.eval()
targets = self.example_target
with torch.no_grad():
out = model(images)
return (out, )
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
from torchbenchmark.util.framework.vision.model_factory import TorchVisionModel
from torchbenchmark.tasks import COMPUTER_VISION
import torch.optim as optim
import torch
import torchvision.models as models
class Model(TorchVisionModel):
task = COMPUTER_VISION.CLASSIFICATION
# Original train batch size: 512, out of memory on V100 GPU
# Use hierarchical batching to scale down: 512 = batch_size (32) * epoch_size (16)
# Source: https://github.com/forresti/SqueezeNet
DEFAULT_TRAIN_BSIZE = 32
DEFAULT_EVAL_BSIZE = 16
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(model_name="squeezenet1_1", test=test, device=device, jit=jit,
batch_size=batch_size, weights=models.SqueezeNet1_1_Weights.IMAGENET1K_V1,
extra_args=extra_args)
self.epoch_size = 16
def train(self):
optimizer = optim.Adam(self.model.parameters())
loss = torch.nn.CrossEntropyLoss()
optimizer.zero_grad()
for _ in range(self.epoch_size):
pred = self.model(*self.example_inputs)
y = torch.empty(pred.shape[0], dtype=torch.long, device=self.device).random_(pred.shape[1])
loss(pred, y).backward()
optimizer.step()
|
import argparse
import random
from collections import deque
import math
import gym
import numpy as np
class ActionRepeatWrapper(gym.Wrapper):
def __init__(self, env, repeat_multiplier=8):
super().__init__(env)
self.action_space = gym.spaces.Box(
-1.0, 1.0, shape=(1 + self.env.action_space.shape[0],)
)
self.repeat_multiplier = repeat_multiplier / 2.0
def step(self, action):
repeat_action = max(math.floor((action[0] + 1.0) * self.repeat_multiplier), 1)
main_action = action[1:]
total_reward = 0
for _ in range(repeat_action):
next_state, reward, done, _ = self.env.step(main_action)
total_reward += reward
return next_state, total_reward, done, {}
class ChannelsFirstWrapper(gym.ObservationWrapper):
"""
Some pixel-based gym environments use a (Height, Width, Channel) image format.
This wrapper rolls those axes to (Channel, Height, Width) to work with pytorch
Conv2D layers.
"""
def __init__(self, env):
super().__init__(env)
self.observation_space.shape = (
env.observation_space.shape[-1],
) + env.observation_space.shape[:-1]
def observation(self, frame):
frame = np.transpose(frame, (2, 0, 1))
return np.ascontiguousarray(frame)
class NormalizeObservationSpace(gym.ObservationWrapper):
def __init__(self, env, obs_mean, obs_std):
super().__init__(env)
self.mean = obs_mean
self.std = obs_std + 1e-5
def observation(self, x):
return (x - self.mean) / self.std
class NormalizeContinuousActionSpace(gym.ActionWrapper):
def __init__(self, env):
super().__init__(env)
self._true_action_space = env.action_space
self.action_space = gym.spaces.Box(
low=-1.0, high=1.0, shape=self._true_action_space.shape, dtype=np.float32,
)
def action(self, action):
true_delta = self._true_action_space.high - self._true_action_space.low
norm_delta = self.action_space.high - self.action_space.low
action = (action - self.action_space.low) / norm_delta
action = action * true_delta + self._true_action_space.low
return action
def robosuite_action_adjustment(robosuite_env, verbose=False):
if verbose:
action_space = robosuite_env.action_space
high = action_space.high
same_high = np.all(high == high[0])
low = action_space.low
same_low = np.all(low == low[0])
shape = action_space.shape[0]
print("RoboSuite Action Space Report:")
if same_high and same_low:
print(f"Uniformly Bounded Action Space in [{low[0]}, {high[0]}]^{shape}")
else:
print(f"Non-uniform Bounded Action Space with elements = {zip(low, high)}")
print("\nAttempting to normalize action space using dc.envs.Normalize...\n")
env = NormalizeContinuousActionSpace(robosuite_env)
if verbose:
action_space = env.action_space
high = action_space.high
same_high = np.all(high == high[0])
low = action_space.low
same_low = np.all(low == low[0])
shape = action_space.shape[0]
print("Normalized RoboSuite Action Space Report:")
if same_high and same_low:
print(f"Uniformly Bounded Action Space in [{low[0]}, {high[0]}]^{shape}")
else:
print(f"Non-uniform Bounded Action Space with elements = {zip(low, high)}")
return env
class FlattenObsWrapper(gym.ObservationWrapper):
"""
Simple wrapper that flattens an image observation
into a state vector when CNNs are overkill.
"""
def __init__(self, env):
super().__init__(env)
self.observation_space.shape = (np.prod(env.observation_space.shape),)
def observation(self, obs):
return obs.flatten()
class ConcatObsWrapper(gym.ObservationWrapper):
def __init__(self, env):
super().__init__(env)
obs_space_shape = sum(x.shape[0] for x in self.observation_space)
self.observation_space.shape = (obs_space_shape,)
def observation(self, obs):
return np.concatenate(obs, axis=0)
def highway_env(env_id):
"""
Convenience function to turn all the highway_env
environments into continuous control tasks.
highway_env: https://highway-env.readthedocs.io/en/latest/index.html
"""
import gym
import highway_env
env = gym.make(env_id)
env.configure({"action": {"type": "ContinuousAction"}})
env.reset()
env = NormalizeContinuousActionSpace(env)
env = FlattenObsWrapper(env)
return env
class DiscreteActionWrapper(gym.ActionWrapper):
"""
This is intended to let the action be any scalar
(float or int) or np array (float or int) of size 1.
floats are cast to ints using python's standard rounding.
"""
def __init__(self, env):
super().__init__(env)
self.action_space.shape = (env.action_space.n,)
def action(self, action):
if isinstance(action, np.ndarray):
if len(action.shape) > 0:
action = action[0]
return int(action)
class FrameStack(gym.Wrapper):
def __init__(self, env, num_stack):
gym.Wrapper.__init__(self, env)
self._k = num_stack
self._frames = deque([], maxlen=num_stack)
shp = env.observation_space.shape
self.observation_space = gym.spaces.Box(
low=0,
high=1,
shape=((shp[0] * num_stack,) + shp[1:]),
dtype=env.observation_space.dtype,
)
def reset(self):
obs = self.env.reset()
for _ in range(self._k):
self._frames.append(obs)
return self._get_obs()
def step(self, action):
obs, reward, done, info = self.env.step(action)
self._frames.append(obs)
return self._get_obs(), reward, done, info
def _get_obs(self):
assert len(self._frames) == self._k
return np.concatenate(list(self._frames), axis=0)
class GoalBasedWrapper(gym.ObservationWrapper):
"""
Some goal-based envs (like the Gym Robotics suite) use dictionary observations
with one entry for the current state and another to describe the goal. This
wrapper concatenates those into a single vector so it can be used just like
any other env.
"""
def __init__(self, env):
super().__init__(env)
self.observation_space.shape = (
env.observation_space["observation"].shape[0]
+ env.observation_space["desired_goal"].shape[0],
)
def observation(self, obs_dict):
return self._flatten_obs(obs_dict)
def _flatten_obs(self, obs_dict):
return np.concatenate((obs_dict["observation"], obs_dict["desired_goal"]))
def add_gym_args(parser):
"""
Add a --env_id cl flag to an argparser
"""
parser.add_argument("--env_id", type=str, default="Pendulum-v1")
parser.add_argument("--seed", type=int, default=123)
def load_gym(env_id="CartPole-v1", seed=None, normalize_action_space=True, **_):
"""
Load an environment from OpenAI gym (or pybullet_gym, if installed)
"""
# optional pybullet import
try:
import pybullet
import pybulletgym
except ImportError:
pass
env = gym.make(env_id)
if normalize_action_space and isinstance(env.action_space, gym.spaces.Box):
env = NormalizeContinuousActionSpace(env)
if seed is None:
seed = random.randint(1, 100000)
env.reset(seed=seed)
return env
def add_dmc_args(parser):
"""
Add cl flags associated with the deepmind control suite to a parser
"""
parser.add_argument("--domain_name", type=str, default="fish")
parser.add_argument("--task_name", type=str, default="swim")
parser.add_argument(
"--from_pixels", action="store_true", help="Use image observations"
)
parser.add_argument("--height", type=int, default=84)
parser.add_argument("--width", type=int, default=84)
parser.add_argument("--camera_id", type=int, default=0)
parser.add_argument("--frame_skip", type=int, default=1)
parser.add_argument("--frame_stack", type=int, default=3)
parser.add_argument("--channels_last", action="store_true")
parser.add_argument("--rgb", action="store_true")
parser.add_argument("--seed", type=int, default=231)
def add_atari_args(parser):
parser.add_argument("--game_id", type=str, default="Boxing-v0")
parser.add_argument("--noop_max", type=int, default=30)
parser.add_argument("--frame_skip", type=int, default=1)
parser.add_argument("--screen_size", type=int, default=84)
parser.add_argument("--terminal_on_life_loss", action="store_true")
parser.add_argument("--rgb", action="store_true")
parser.add_argument("--normalize", action="store_true")
parser.add_argument("--frame_stack", type=int, default=4)
parser.add_argument("--seed", type=int, default=231)
def load_atari(
game_id,
seed=None,
noop_max=30,
frame_skip=1,
screen_size=84,
terminal_on_life_loss=False,
rgb=False,
normalize=False,
frame_stack=4,
clip_reward=True,
**_,
):
"""
Load a game from the Atari benchmark, with the usual settings
Note that the simplest game ids (e.g. Boxing-v0) come with frame
skipping by default, and you'll get an error if the frame_skp arg > 1.
Use `BoxingNoFrameskip-v0` with frame_skip > 1.
"""
env = gym.make(game_id)
if seed is None:
seed = random.randint(1, 100000)
env.reset(seed=seed)
env = gym.wrappers.AtariPreprocessing(
env,
noop_max=noop_max,
frame_skip=frame_skip,
screen_size=screen_size,
terminal_on_life_loss=terminal_on_life_loss,
grayscale_obs=False, # use GrayScale wrapper instead...
scale_obs=normalize,
)
if not rgb:
env = gym.wrappers.GrayScaleObservation(env, keep_dim=True)
if clip_reward:
env = ClipReward(env)
env = ChannelsFirstWrapper(env)
env = FrameStack(env, num_stack=frame_stack)
env = DiscreteActionWrapper(env)
return env
class ClipReward(gym.RewardWrapper):
def __init__(self, env, low=-1.0, high=1.0):
super().__init__(env)
self._clip_low = low
self._clip_high = high
def reward(self, rew):
return max(min(rew, self._clip_high), self._clip_low)
def load_dmc(
domain_name,
task_name,
seed=None,
from_pixels=False,
frame_stack=1,
height=84,
width=84,
camera_id=0,
frame_skip=1,
channels_last=False,
rgb=False,
**_,
):
"""
Load a task from the deepmind control suite.
Uses dmc2gym (https://github.com/denisyarats/dmc2gym)
Note that setting seed=None (the default) picks a random seed
"""
import dmc2gym
if seed is None:
seed = random.randint(1, 100000)
env = dmc2gym.make(
domain_name=domain_name,
task_name=task_name,
from_pixels=from_pixels,
height=height,
width=width,
camera_id=camera_id,
visualize_reward=False,
frame_skip=frame_skip,
channels_first=not channels_last
if rgb
else False, # if we're using RGB, set the channel order here
)
if not rgb and from_pixels:
env = gym.wrappers.GrayScaleObservation(env, keep_dim=True)
env = ChannelsFirstWrapper(env)
if from_pixels:
env = FrameStack(env, num_stack=frame_stack)
return env
|
import dataclasses
@dataclasses.dataclass
class SACConfig:
env_id = "Pendulum-v1"
seed = 123
num_steps = 1
transitions_per_step = 1
max_episode_steps = 10
batch_size = 512
tau = 0.005
actor_lr = 1e-4
critic_lr = 1e-4
gamma = 0.99
init_alpha = 0.1
alpha_lr = 1e-4
buffer_size = 1_000_000
eval_interval = 5000
eval_episodes = 10
warmup_steps = 1
render = False
actor_clip = 0.0
critic_clip = 0.0
name = "sac_run"
actor_l2 = 0.0
critic_l2 = 0.0
target_delay = 2
actor_delay = 1
save_interval = 100_000
verbosy = 0
gradient_updates_per_step = 1
prioritized_replay = False
skip_save_to_disk = True
skip_log_to_disk = True
discrete_actions = False
log_std_low = -10.0
log_std_high = 2.0
self_regularized = False
sr_max_critic_updates_per_step = 10
sr_critic_target_improvement_init = 0.7
sr_critic_target_improvement_final = 0.9
train_env_path = "input_data/train_env.pkl"
test_env_path = "input_data/test_env.pkl"
|
import torch
import os
import copy
import pickle
import math
from itertools import chain
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import REINFORCEMENT_LEARNING
from typing import Tuple
from .config import SACConfig
from .envs import load_gym
from .sac import SACAgent
from .replay import PrioritizedReplayBuffer, ReplayBuffer
from .utils import hard_update, soft_update
def learn_standard(
buffer,
target_agent,
agent,
actor_optimizer,
critic_optimizer,
log_alpha_optimizer,
target_entropy,
batch_size,
log_alpha,
gamma,
critic_clip,
actor_clip,
update_policy=True,
device=None,
):
per = isinstance(buffer, PrioritizedReplayBuffer)
if per:
batch, imp_weights, priority_idxs = buffer.sample(batch_size)
imp_weights = imp_weights.to(device)
else:
batch = buffer.sample(batch_size)
# prepare transitions for models
state_batch, action_batch, reward_batch, next_state_batch, done_batch = batch
state_batch = state_batch.to(device)
next_state_batch = next_state_batch.to(device)
action_batch = action_batch.to(device)
reward_batch = reward_batch.to(device)
done_batch = done_batch.to(device)
agent.train()
###################
## CRITIC UPDATE ##
###################
alpha = torch.exp(log_alpha)
with torch.no_grad():
action_dist_s1 = agent.actor(next_state_batch)
action_s1 = action_dist_s1.rsample()
logp_a1 = action_dist_s1.log_prob(action_s1).sum(-1, keepdim=True)
target_action_value_s1 = torch.min(
target_agent.critic1(next_state_batch, action_s1),
target_agent.critic2(next_state_batch, action_s1),
)
td_target = reward_batch + gamma * (1.0 - done_batch) * (
target_action_value_s1 - (alpha * logp_a1)
)
# update critics
agent_critic1_pred = agent.critic1(state_batch, action_batch)
agent_critic2_pred = agent.critic2(state_batch, action_batch)
td_error1 = td_target - agent_critic1_pred
td_error2 = td_target - agent_critic2_pred
critic_loss = 0.5 * (td_error1 ** 2 + td_error2 ** 2)
if per:
critic_loss *= imp_weights
critic_loss = critic_loss.mean()
critic_optimizer.zero_grad()
critic_loss.backward()
if critic_clip:
torch.nn.utils.clip_grad_norm_(
chain(agent.critic1.parameters(), agent.critic2.parameters()), critic_clip
)
critic_optimizer.step()
if update_policy:
##################
## ACTOR UPDATE ##
##################
dist = agent.actor(state_batch)
agent_actions = dist.rsample()
logp_a = dist.log_prob(agent_actions).sum(-1, keepdim=True)
actor_loss = -(
torch.min(
agent.critic1(state_batch, agent_actions),
agent.critic2(state_batch, agent_actions),
)
- (alpha.detach() * logp_a)
).mean()
actor_optimizer.zero_grad()
actor_loss.backward()
if actor_clip:
torch.nn.utils.clip_grad_norm_(agent.actor.parameters(), actor_clip)
actor_optimizer.step()
##################
## ALPHA UPDATE ##
##################
alpha_loss = (-alpha * (logp_a + target_entropy).detach()).mean()
log_alpha_optimizer.zero_grad()
alpha_loss.backward()
log_alpha_optimizer.step()
if per:
new_priorities = (abs(td_error1) + 1e-5).cpu().detach().squeeze(1).numpy()
buffer.update_priorities(priority_idxs, new_priorities)
class Model(BenchmarkModel):
task = REINFORCEMENT_LEARNING.OTHER_RL
# Original train batch size: 256
# Source: https://github.com/pranz24/pytorch-soft-actor-critic/blob/398595e0d9dca98b7db78c7f2f939c969431871a/main.py#L31
# This model doesn't support customizing batch size, or data prefetching
DEFAULT_TRAIN_BSIZE = 256
DEFAULT_EVAL_BSIZE = 256
ALLOW_CUSTOMIZE_BSIZE = False
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.args = SACConfig()
self.args.batch_size = self.batch_size
# Construct agent
current_dir = os.path.dirname(os.path.abspath(__file__))
self.train_env = load_gym(self.args.env_id, self.args.seed)
self.test_env = load_gym(self.args.env_id, self.args.seed)
self.obs_shape = self.train_env.observation_space.shape
self.actions_shape = self.train_env.action_space.shape
self.agent = SACAgent(self.obs_shape[0], self.actions_shape[0],
self.args.log_std_low, self.args.log_std_high, self.device)
if self.args.prioritized_replay:
buffer_t = PrioritizedReplayBuffer
else:
buffer_t = ReplayBuffer
self.buffer = buffer_t(
self.args.buffer_size,
device=self.device,
state_shape=self.train_env.observation_space.shape,
state_dtype=float,
action_shape=(1,),
)
self.learning_method = "Standard"
self.agent.to(device)
if not self.args.self_regularized:
# initialize target networks
self.target_agent = copy.deepcopy(self.agent)
self.target_agent.to(device)
hard_update(self.target_agent.critic1, self.agent.critic1)
hard_update(self.target_agent.critic2, self.agent.critic2)
self.target_agent.train()
self.critic_optimizer = torch.optim.Adam(
chain(self.agent.critic1.parameters(), self.agent.critic2.parameters(),),
lr=self.args.critic_lr,
weight_decay=self.args.critic_l2,
betas=(0.9, 0.999),
)
self.actor_optimizer = torch.optim.Adam(
self.agent.actor.parameters(),
lr=self.args.actor_lr,
weight_decay=self.args.actor_l2,
betas=(0.9, 0.999),
)
self.log_alpha = torch.Tensor([math.log(self.args.init_alpha)]).to(device)
self.log_alpha.requires_grad = True
self.log_alpha_optimizer = torch.optim.Adam([self.log_alpha], lr=self.args.alpha_lr, betas=(0.5, 0.999))
if not self.args.discrete_actions:
self.target_entropy = -self.train_env.action_space.shape[0]
else:
self.target_entropy = -math.log(1.0 / self.train_env.action_space.n) * 0.98
if self.args.self_regularized:
# the critic target improvement ratio is annealed during training
self.critic_target_imp_slope = (
self.args.sr_critic_target_improvement_final - self.args.sr_critic_target_improvement_init
) / self.args.num_steps
self.current_target_imp = lambda step: min(
self.args.sr_critic_target_improvement_init + self.critic_target_imp_slope * step,
self.args.sr_critic_target_improvement_final,
)
def get_module(self):
model = self.agent.actor
state = self.train_env.reset()
action = self.agent.sample_action(state)
next_state, reward, done, info = self.train_env.step(action)
self.buffer.push(state, action, reward, next_state, done)
batch = self.buffer.sample(self.args.batch_size)
state_batch, action_batch, reward_batch, next_state_batch, done_batch = batch
state_batch = state_batch.to(self.device)
return model, (state_batch, )
def set_module(self, new_model):
self.agent.actor = new_model
def train(self):
# Setup
self.target_agent.train()
done = True
niter = 1
for step in range(niter):
if done:
state = self.train_env.reset()
steps_this_ep = 0
done = False
action = self.agent.sample_action(state)
next_state, reward, done, info = self.train_env.step(action)
self.buffer.push(state, action, reward, next_state, done)
state = next_state
steps_this_ep += 1
if steps_this_ep >= self.args.max_episode_steps:
done = True
for _ in range(self.args.gradient_updates_per_step):
learn_standard(
buffer=self.buffer,
target_agent=self.target_agent,
agent=self.agent,
actor_optimizer=self.actor_optimizer,
critic_optimizer=self.critic_optimizer,
log_alpha=self.log_alpha,
log_alpha_optimizer=self.log_alpha_optimizer,
target_entropy=self.target_entropy,
batch_size=self.args.batch_size,
gamma=self.args.gamma,
critic_clip=self.args.critic_clip,
actor_clip=self.args.actor_clip,
update_policy=step % self.args.actor_delay == 0,
device=self.device
)
# move target model towards training model
if not self.args.self_regularized and (step % self.args.target_delay == 0):
soft_update(self.target_agent.critic1, self.agent.critic1, self.args.tau)
soft_update(self.target_agent.critic2, self.agent.critic2, self.args.tau)
def eval(self) -> Tuple[torch.Tensor]:
niter = 1
with torch.no_grad():
discount= 1.0
episode_return_history = []
for episode in range(niter):
episode_return = 0.0
state = self.test_env.reset()
done, info = False, {}
for step_num in range(self.args.max_episode_steps):
if done:
break
action = self.agent.forward(state)
state, reward, done, info = self.test_env.step(action)
episode_return += reward * (discount ** step_num)
episode_return_history.append(episode_return)
retval = torch.tensor(episode_return_history)
return (torch.tensor(action), )
def get_optimizer(self):
return (self.actor_optimizer, self.critic_optimizer, self.log_alpha_optimizer)
def set_optimizer(self, optimizer) -> None:
self.actor_optimizer, self.critic_optimizer, self.log_alpha_optimizer = optimizer
|
import argparse
import copy
import math
import os
from itertools import chain
import numpy as np
import tensorboardX
import torch
import torch.nn.functional as F
import tqdm
from . import envs, nets, replay, utils
class SACAgent:
def __init__(
self,
obs_space_size,
act_space_size,
log_std_low,
log_std_high,
device,
actor_net_cls=nets.StochasticActor,
critic_net_cls=nets.BigCritic,
hidden_size=1024,
):
self.actor = actor_net_cls(
obs_space_size,
act_space_size,
log_std_low,
log_std_high,
dist_impl="pyd",
hidden_size=hidden_size,
)
self.critic1 = critic_net_cls(obs_space_size, act_space_size, hidden_size)
self.critic2 = critic_net_cls(obs_space_size, act_space_size, hidden_size)
self.device = device
def to(self, device):
self.actor = self.actor.to(device)
self.critic1 = self.critic1.to(device)
self.critic2 = self.critic2.to(device)
def eval(self):
self.actor.eval()
self.critic1.eval()
self.critic2.eval()
def train(self):
self.actor.train()
self.critic1.train()
self.critic2.train()
def save(self, path):
actor_path = os.path.join(path, "actor.pt")
critic1_path = os.path.join(path, "critic1.pt")
critic2_path = os.path.join(path, "critic2.pt")
torch.save(self.actor.state_dict(), actor_path)
torch.save(self.critic1.state_dict(), critic1_path)
torch.save(self.critic2.state_dict(), critic2_path)
def load(self, path):
actor_path = os.path.join(path, "actor.pt")
critic1_path = os.path.join(path, "critic1.pt")
critic2_path = os.path.join(path, "critic2.pt")
self.actor.load_state_dict(torch.load(actor_path))
self.critic1.load_state_dict(torch.load(critic1_path))
self.critic2.load_state_dict(torch.load(critic2_path))
def forward(self, state, from_cpu=True):
if from_cpu:
state = self.process_state(state)
self.actor.eval()
with torch.no_grad():
act_dist = self.actor.forward(state)
act = act_dist.mean
self.actor.train()
if from_cpu:
act = self.process_act(act)
return act
def sample_action(self, state, from_cpu=True):
if from_cpu:
state = self.process_state(state)
self.actor.eval()
with torch.no_grad():
act_dist = self.actor.forward(state)
act = act_dist.sample()
self.actor.train()
if from_cpu:
act = self.process_act(act)
return act
def process_state(self, state):
return torch.from_numpy(np.expand_dims(state, 0).astype(np.float32)).to(
self.device
)
def process_act(self, act):
return np.squeeze(act.clamp(-1.0, 1.0).cpu().numpy(), 0)
class SACDAgent(SACAgent):
def __init__(self, obs_space_size, act_space_size):
self.actor = nets.BaselineDiscreteActor(obs_space_size, act_space_size)
self.critic1 = nets.BaselineDiscreteCritic(obs_space_size, act_space_size)
self.critic2 = nets.BaselineDiscreteCritic(obs_space_size, act_space_size)
def forward(self, state):
state = self.process_state(state)
self.actor.eval()
with torch.no_grad():
act_dist = self.actor.forward(state)
act = torch.argmax(act_dist.probs, dim=1)
self.actor.train()
return self.process_act(act)
|
import numpy as np
import torch
def unique(sorted_array):
"""
More efficient implementation of np.unique for sorted arrays
:param sorted_array: (np.ndarray)
:return:(np.ndarray) sorted_array without duplicate elements
"""
if len(sorted_array) == 1:
return sorted_array
left = sorted_array[:-1]
right = sorted_array[1:]
uniques = np.append(right != left, True)
return sorted_array[uniques]
class SegmentTree:
def __init__(self, capacity, operation, neutral_element):
"""
Build a Segment Tree data structure.
https://en.wikipedia.org/wiki/Segment_tree
Can be used as regular array that supports Index arrays, but with two
important differences:
a) setting item's value is slightly slower.
It is O(lg capacity) instead of O(1).
b) user has access to an efficient ( O(log segment size) )
`reduce` operation which reduces `operation` over
a contiguous subsequence of items in the array.
:param capacity: (int) Total size of the array - must be a power of two.
:param operation: (lambda (Any, Any): Any) operation for combining elements (eg. sum, max) must form a
mathematical group together with the set of possible values for array elements (i.e. be associative)
:param neutral_element: (Any) neutral element for the operation above. eg. float('-inf') for max and 0 for sum.
"""
assert (
capacity > 0 and capacity & (capacity - 1) == 0
), "capacity must be positive and a power of 2."
self._capacity = capacity
self._value = [neutral_element for _ in range(2 * capacity)]
self._operation = operation
self.neutral_element = neutral_element
def _reduce_helper(self, start, end, node, node_start, node_end):
if start == node_start and end == node_end:
return self._value[node]
mid = (node_start + node_end) // 2
if end <= mid:
return self._reduce_helper(start, end, 2 * node, node_start, mid)
else:
if mid + 1 <= start:
return self._reduce_helper(start, end, 2 * node + 1, mid + 1, node_end)
else:
return self._operation(
self._reduce_helper(start, mid, 2 * node, node_start, mid),
self._reduce_helper(mid + 1, end, 2 * node + 1, mid + 1, node_end),
)
def reduce(self, start=0, end=None):
"""
Returns result of applying `self.operation`
to a contiguous subsequence of the array.
self.operation(arr[start], operation(arr[start+1], operation(... arr[end])))
:param start: (int) beginning of the subsequence
:param end: (int) end of the subsequences
:return: (Any) result of reducing self.operation over the specified range of array elements.
"""
if end is None:
end = self._capacity
if end < 0:
end += self._capacity
end -= 1
return self._reduce_helper(start, end, 1, 0, self._capacity - 1)
def __setitem__(self, idx, val):
# indexes of the leaf
idxs = idx + self._capacity
self._value[idxs] = val
if isinstance(idxs, int):
idxs = np.array([idxs])
# go up one level in the tree and remove duplicate indexes
idxs = unique(idxs // 2)
while len(idxs) > 1 or idxs[0] > 0:
# as long as there are non-zero indexes, update the corresponding values
self._value[idxs] = self._operation(
self._value[2 * idxs], self._value[2 * idxs + 1]
)
# go up one level in the tree and remove duplicate indexes
idxs = unique(idxs // 2)
def __getitem__(self, idx):
assert np.max(idx) < self._capacity
assert 0 <= np.min(idx)
return self._value[self._capacity + idx]
class SumSegmentTree(SegmentTree):
def __init__(self, capacity):
super(SumSegmentTree, self).__init__(
capacity=capacity, operation=np.add, neutral_element=0.0
)
self._value = np.array(self._value)
def sum(self, start=0, end=None):
"""
Returns arr[start] + ... + arr[end]
:param start: (int) start position of the reduction (must be >= 0)
:param end: (int) end position of the reduction (must be < len(arr), can be None for len(arr) - 1)
:return: (Any) reduction of SumSegmentTree
"""
return super(SumSegmentTree, self).reduce(start, end)
def find_prefixsum_idx(self, prefixsum):
"""
Find the highest index `i` in the array such that
sum(arr[0] + arr[1] + ... + arr[i - i]) <= prefixsum for each entry in prefixsum
if array values are probabilities, this function
allows to sample indexes according to the discrete
probability efficiently.
:param prefixsum: (np.ndarray) float upper bounds on the sum of array prefix
:return: (np.ndarray) highest indexes satisfying the prefixsum constraint
"""
if isinstance(prefixsum, float):
prefixsum = np.array([prefixsum])
assert 0 <= np.min(prefixsum)
assert np.max(prefixsum) <= self.sum() + 1e-5
assert isinstance(prefixsum[0], float)
idx = np.ones(len(prefixsum), dtype=int)
cont = np.ones(len(prefixsum), dtype=bool)
while np.any(cont): # while not all nodes are leafs
idx[cont] = 2 * idx[cont]
prefixsum_new = np.where(
self._value[idx] <= prefixsum, prefixsum - self._value[idx], prefixsum
)
# prepare update of prefixsum for all right children
idx = np.where(
np.logical_or(self._value[idx] > prefixsum, np.logical_not(cont)),
idx,
idx + 1,
)
# Select child node for non-leaf nodes
prefixsum = prefixsum_new
# update prefixsum
cont = idx < self._capacity
# collect leafs
return idx - self._capacity
class MinSegmentTree(SegmentTree):
def __init__(self, capacity):
super(MinSegmentTree, self).__init__(
capacity=capacity, operation=np.minimum, neutral_element=float("inf")
)
self._value = np.array(self._value)
def min(self, start=0, end=None):
"""
Returns min(arr[start], ..., arr[end])
:param start: (int) start position of the reduction (must be >= 0)
:param end: (int) end position of the reduction (must be < len(arr), can be None for len(arr) - 1)
:return: (Any) reduction of MinSegmentTree
"""
return super(MinSegmentTree, self).reduce(start, end)
class ReplayBufferStorage:
def __init__(self, size, obs_shape, act_shape, device, obs_dtype=torch.float32):
self.s_dtype = obs_dtype
self.device = device
# buffer arrays
self.s_stack = torch.zeros((size,) + obs_shape, dtype=self.s_dtype, device=device)
self.action_stack = torch.zeros((size,) + act_shape, dtype=torch.float32, device=device)
self.reward_stack = torch.zeros((size, 1), dtype=torch.float32, device=device)
self.s1_stack = torch.zeros((size,) + obs_shape, dtype=self.s_dtype, device=device)
self.done_stack = torch.zeros((size, 1), dtype=torch.int, device=device)
self.obs_shape = obs_shape
self.size = size
self._next_idx = 0
self._max_filled = 0
def __len__(self):
return self._max_filled
def add(self, s, a, r, s_1, d):
# this buffer supports batched experience
if len(s.shape) > len(self.obs_shape):
# there must be a batch dimension
num_samples = len(s)
else:
num_samples = 1
r, d = [r], [d]
if not isinstance(s, torch.Tensor):
# convert states to numpy (checking for LazyFrames)
if not isinstance(s, np.ndarray):
s = np.asarray(s)
if not isinstance(s_1, np.ndarray):
s_1 = np.asarray(s_1)
# convert to torch tensors
s = torch.from_numpy(s)
a = torch.from_numpy(a).float()
r = torch.Tensor(r).float()
s_1 = torch.from_numpy(s_1)
d = torch.Tensor(d).int()
# make sure tensors are floats not doubles
if self.s_dtype is torch.float32:
s = s.float()
s_1 = s_1.float()
s = s.to(self.device)
a = a.to(self.device)
r = r.to(self.device)
s_1 = s_1.to(self.device)
d = d.int().to(self.device)
# Store at end of buffer. Wrap around if past end.
R = np.arange(self._next_idx, self._next_idx + num_samples) % self.size
self.s_stack[R] = s
self.action_stack[R] = a
self.reward_stack[R] = r
self.s1_stack[R] = s_1
self.done_stack[R] = d
# Advance index.
self._max_filled = min(
max(self._next_idx + num_samples, self._max_filled), self.size
)
self._next_idx = (self._next_idx + num_samples) % self.size
return R
def __getitem__(self, indices):
try:
iter(indices)
except ValueError:
raise IndexError(
"ReplayBufferStorage getitem called with indices object that is not iterable"
)
# converting states and actions to float here instead of inside the learning loop
# of each agent seems fine for now.
state = self.s_stack[indices].float()
action = self.action_stack[indices].float()
reward = self.reward_stack[indices]
next_state = self.s1_stack[indices].float()
done = self.done_stack[indices]
return (state, action, reward, next_state, done)
def __setitem__(self, indices, experience):
s, a, r, s1, d = experience
self.s_stack[indices] = s.float()
self.action_stack[indices] = a.float()
self.reward_stack[indices] = r
self.s1_stack[indices] = s1.float()
self.done_stack[indices] = d
def get_all_transitions(self):
return (
self.s_stack[: self._max_filled],
self.action_stack[: self._max_filled],
self.reward_stack[: self._max_filled],
self.s1_stack[: self._max_filled],
self.done_stack[: self._max_filled],
)
class ReplayBuffer:
def __init__(self, size, device, state_shape=None, action_shape=None, state_dtype=float):
self.device=device
self._maxsize = size
self.state_shape = state_shape
self.state_dtype = self._convert_dtype(state_dtype)
self.action_shape = action_shape
self._storage = None
assert self.state_shape, "Must provide shape of state space to ReplayBuffer"
assert self.action_shape, "Must provide shape of action space to ReplayBuffer"
def _convert_dtype(self, dtype):
if dtype in [int, np.uint8, torch.uint8]:
return torch.uint8
elif dtype in [float, np.float32, np.float64, torch.float32, torch.float64]:
return torch.float32
elif dtype in ["int32", np.int32]:
return torch.int32
else:
raise ValueError(f"Uncreocgnized replay buffer dtype: {dtype}")
def __len__(self):
return len(self._storage) if self._storage is not None else 0
def push(self, state, action, reward, next_state, done):
if self._storage is None:
self._storage = ReplayBufferStorage(
self._maxsize,
device=self.device,
obs_shape=self.state_shape,
act_shape=self.action_shape,
obs_dtype=self.state_dtype,
)
return self._storage.add(state, action, reward, next_state, done)
def sample(self, batch_size, get_idxs=False):
random_idxs = torch.randint(len(self._storage), (batch_size,)).to(self.device)
if get_idxs:
return self._storage[random_idxs], random_idxs.cpu().numpy()
else:
return self._storage[random_idxs]
def get_all_transitions(self):
return self._storage.get_all_transitions()
def load_experience(self, s, a, r, s1, d):
assert (
s.shape[0] <= self._maxsize
), "Experience dataset is larger than the buffer."
if len(r.shape) < 2:
r = np.expand_dims(r, 1)
if len(d.shape) < 2:
d = np.expand_dims(d, 1)
self.push(s, a, r, s1, d)
class PrioritizedReplayBuffer(ReplayBuffer):
def __init__(
self, size, state_shape, action_shape, state_dtype=float, alpha=0.6, beta=1.0
):
super(PrioritizedReplayBuffer, self).__init__(
size, state_shape, action_shape, state_dtype
)
assert alpha >= 0
self.alpha = alpha
self.beta = beta
it_capacity = 1
while it_capacity < size:
it_capacity *= 2
self._it_sum = SumSegmentTree(it_capacity)
self._it_min = MinSegmentTree(it_capacity)
self._max_priority = 1.0
def push(self, s, a, r, s_1, d, priorities=None):
R = super().push(s, a, r, s_1, d)
if priorities is None:
priorities = self._max_priority
self._it_sum[R] = priorities ** self.alpha
self._it_min[R] = priorities ** self.alpha
def _sample_proportional(self, batch_size):
mass = []
total = self._it_sum.sum(0, len(self._storage) - 1)
mass = np.random.random(size=batch_size) * total
idx = self._it_sum.find_prefixsum_idx(mass)
return idx
def sample(self, batch_size):
idxes = self._sample_proportional(batch_size)
p_min = self._it_min.min() / self._it_sum.sum()
max_weight = (p_min * len(self._storage)) ** (-self.beta)
p_sample = self._it_sum[idxes] / self._it_sum.sum()
weights = (p_sample * len(self._storage)) ** (-self.beta) / max_weight
return self._storage[idxes], torch.from_numpy(weights), idxes
def sample_uniform(self, batch_size):
return super().sample(batch_size, get_idxs=True)
def update_priorities(self, idxes, priorities):
assert len(idxes) == len(priorities)
assert np.min(priorities) > 0
assert np.min(idxes) >= 0
assert np.max(idxes) < len(self._storage)
self._it_sum[idxes] = priorities ** self.alpha
self._it_min[idxes] = priorities ** self.alpha
self._max_priority = max(self._max_priority, np.max(priorities))
class MultiPriorityBuffer(ReplayBuffer):
def __init__(
self,
size,
trees,
state_shape,
action_shape,
state_dtype=float,
alpha=0.6,
beta=1.0,
):
super(MultiPriorityBuffer, self).__init__(
size, state_shape, action_shape, state_dtype
)
assert alpha >= 0
self.alpha = alpha
self.beta = beta
it_capacity = 1
while it_capacity < size:
it_capacity *= 2
self.sum_trees = [SumSegmentTree(it_capacity) for _ in range(trees)]
self.min_trees = [MinSegmentTree(it_capacity) for _ in range(trees)]
self._max_priority = 1.0
def push(self, s, a, r, s_1, d, priorities=None):
R = super().push(s, a, r, s_1, d)
if priorities is None:
priorities = self._max_priority
for sum_tree in self.sum_trees:
sum_tree[R] = priorities ** self.alpha
for min_tree in self.min_trees:
min_tree[R] = priorities ** self.alpha
def _sample_proportional(self, batch_size, tree_num):
mass = []
total = self.sum_trees[tree_num].sum(0, len(self._storage) - 1)
mass = np.random.random(size=batch_size) * total
idx = self.sum_trees[tree_num].find_prefixsum_idx(mass)
return idx
def sample(self, batch_size, tree_num):
idxes = self._sample_proportional(batch_size, tree_num)
p_min = self.min_trees[tree_num].min() / self.sum_trees[tree_num].sum()
max_weight = (p_min * len(self._storage)) ** (-self.beta)
p_sample = self.sum_trees[tree_num][idxes] / self.sum_trees[tree_num].sum()
weights = (p_sample * len(self._storage)) ** (-self.beta) / max_weight
return self._storage[idxes], torch.from_numpy(weights), idxes
def sample_uniform(self, batch_size):
return super().sample(batch_size, get_idxs=True)
def update_priorities(self, idxes, priorities, tree_num):
assert len(idxes) == len(priorities)
assert np.min(priorities) > 0
assert np.min(idxes) >= 0
assert np.max(idxes) < len(self._storage)
self.sum_trees[tree_num][idxes] = priorities ** self.alpha
self.min_trees[tree_num][idxes] = priorities ** self.alpha
self._max_priority = max(self._max_priority, np.max(priorities))
|
import math
import os
import random
from collections import namedtuple
import gym
import numpy as np
import torch
def clean_hparams_dict(hparams_dict):
return {key: val for key, val in hparams_dict.items() if val}
def get_grad_norm(model):
total_norm = 0.0
for p in model.parameters():
try:
param = p.grad.data
except AttributeError:
continue
else:
param_norm = param.norm(2)
total_norm += param_norm.item() ** 2
total_norm = total_norm ** (1.0 / 2)
return total_norm
def torch_and_pad(x):
if not isinstance(x, np.ndarray):
x = np.array(x)
return torch.from_numpy(x.astype(np.float32)).unsqueeze(0)
def mean(lst):
return float(sum(lst)) / len(lst)
def make_process_dirs(run_name, base_path="dc_saves"):
base_dir = os.path.join(base_path, run_name)
i = 0
while os.path.exists(base_dir + f"_{i}"):
i += 1
base_dir += f"_{i}"
os.makedirs(base_dir)
return base_dir
def compute_conv_output(
inp_shape, kernel_size, padding=(0, 0), dilation=(1, 1), stride=(1, 1)
):
"""
Compute the shape of the output of a torch Conv2d layer using
the formula from the docs.
every argument is a tuple corresponding to (height, width), e.g. kernel_size=(3, 4)
"""
height_out = math.floor(
(
(inp_shape[0] + 2 * padding[0] - dilation[0] * (kernel_size[0] - 1) - 1)
/ stride[0]
)
+ 1
)
width_out = math.floor(
(
(inp_shape[1] + 2 * padding[1] - dilation[1] * (kernel_size[1] - 1) - 1)
/ stride[1]
)
+ 1
)
return height_out, width_out
def soft_update(target, source, tau):
for target_param, param in zip(target.parameters(), source.parameters()):
target_param.data.copy_(target_param.data * (1.0 - tau) + param.data * tau)
def hard_update(target, source):
for target_param, param in zip(target.parameters(), source.parameters()):
target_param.data.copy_(param.data)
""" This is all from: https://github.com/matthiasplappert/keras-rl/blob/master/rl/random.py """
class AnnealedGaussianProcess:
def __init__(self, mu, sigma, sigma_min, n_steps_annealing):
self.mu = mu
self.sigma = sigma
self.n_steps = 0
if sigma_min is not None:
self.m = -float(sigma - sigma_min) / float(n_steps_annealing)
self.c = sigma
self.sigma_min = sigma_min
else:
self.m = 0.0
self.c = sigma
self.sigma_min = sigma
@property
def current_sigma(self):
sigma = max(self.sigma_min, self.m * float(self.n_steps) + self.c)
return sigma
class OrnsteinUhlenbeckProcess(AnnealedGaussianProcess):
def __init__(
self,
theta,
mu=0.0,
sigma=1.0,
dt=1e-2,
x0=None,
size=1,
sigma_min=None,
n_steps_annealing=1000,
):
super(OrnsteinUhlenbeckProcess, self).__init__(
mu=mu, sigma=sigma, sigma_min=sigma_min, n_steps_annealing=n_steps_annealing
)
self.theta = theta
self.mu = mu
self.dt = dt
self.x0 = x0
self.size = size
self.reset_states()
def sample(self):
x = (
self.x_prev
+ self.theta * (self.mu - self.x_prev) * self.dt
+ self.current_sigma * np.sqrt(self.dt) * np.random.normal(size=self.size)
)
self.x_prev = x
self.n_steps += 1
return x
def reset_states(self):
self.x_prev = self.x0 if self.x0 is not None else np.zeros(self.size)
class GaussianExplorationNoise:
def __init__(self, size, start_scale=1.0, final_scale=0.1, steps_annealed=1000):
assert start_scale >= final_scale
self.size = size
self.start_scale = start_scale
self.final_scale = final_scale
self.steps_annealed = steps_annealed
self._current_scale = start_scale
self._scale_slope = (start_scale - final_scale) / steps_annealed
def sample(self):
noise = self._current_scale * torch.randn(*self.size)
self._current_scale = max(
self._current_scale - self._scale_slope, self.final_scale
)
return noise.numpy()
def reset_states(self):
pass
|
import os
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
import math
import numpy as np
import torch
import torch.nn.functional as F
from torch import distributions as pyd
from torch import nn
from . import utils
def weight_init(m):
if isinstance(m, nn.Linear):
nn.init.orthogonal_(m.weight.data)
m.bias.data.fill_(0.0)
elif isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
# delta-orthogonal init from https://arxiv.org/pdf/1806.05393.pdf
assert m.weight.size(2) == m.weight.size(3)
m.weight.data.fill_(0.0)
m.bias.data.fill_(0.0)
mid = m.weight.size(2) // 2
gain = nn.init.calculate_gain("relu")
nn.init.orthogonal_(m.weight.data[:, :, mid, mid], gain)
class BigPixelEncoder(nn.Module):
def __init__(self, obs_shape, out_dim=50):
super().__init__()
channels = obs_shape[0]
self.conv1 = nn.Conv2d(channels, 32, kernel_size=3, stride=2)
self.conv2 = nn.Conv2d(32, 32, kernel_size=3, stride=1)
self.conv3 = nn.Conv2d(32, 32, kernel_size=3, stride=1)
self.conv4 = nn.Conv2d(32, 32, kernel_size=3, stride=1)
output_height, output_width = utils.compute_conv_output(
obs_shape[1:], kernel_size=(3, 3), stride=(2, 2)
)
for _ in range(3):
output_height, output_width = utils.compute_conv_output(
(output_height, output_width), kernel_size=(3, 3), stride=(1, 1)
)
self.fc = nn.Linear(output_height * output_width * 32, out_dim)
self.ln = nn.LayerNorm(out_dim)
self.apply(weight_init)
def forward(self, obs):
obs /= 255.0
x = F.relu(self.conv1(obs))
x = F.relu(self.conv2(x))
x = F.relu(self.conv3(x))
x = F.relu(self.conv4(x))
x = x.view(x.size(0), -1)
x = self.fc(x)
x = self.ln(x)
state = torch.tanh(x)
return state
class SmallPixelEncoder(nn.Module):
def __init__(self, obs_shape, out_dim=50):
super().__init__()
channels = obs_shape[0]
self.conv1 = nn.Conv2d(channels, 32, kernel_size=8, stride=4)
self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)
self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)
output_height, output_width = utils.compute_conv_output(
obs_shape[1:], kernel_size=(8, 8), stride=(4, 4)
)
output_height, output_width = utils.compute_conv_output(
(output_height, output_width), kernel_size=(4, 4), stride=(2, 2)
)
output_height, output_width = utils.compute_conv_output(
(output_height, output_width), kernel_size=(3, 3), stride=(1, 1)
)
self.fc = nn.Linear(output_height * output_width * 64, out_dim)
self.apply(weight_init)
def forward(self, obs):
obs /= 255.0
x = F.relu(self.conv1(obs))
x = F.relu(self.conv2(x))
x = F.relu(self.conv3(x))
x = x.view(x.size(0), -1)
state = self.fc(x)
return state
class StochasticActor(nn.Module):
def __init__(
self,
state_space_size,
act_space_size,
log_std_low=-10,
log_std_high=2,
hidden_size=1024,
dist_impl="pyd",
):
super().__init__()
assert dist_impl in ["pyd", "beta"]
self.fc1 = nn.Linear(state_space_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Linear(hidden_size, 2 * act_space_size)
self.log_std_low = log_std_low
self.log_std_high = log_std_high
self.apply(weight_init)
self.dist_impl = dist_impl
def forward(self, state):
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
out = self.fc3(x)
mu, log_std = out.chunk(2, dim=1)
if self.dist_impl == "pyd":
log_std = torch.tanh(log_std)
log_std = self.log_std_low + 0.5 * (
self.log_std_high - self.log_std_low
) * (log_std + 1)
std = log_std.exp()
dist = SquashedNormal(mu, std)
elif self.dist_impl == "beta":
out = 1.0 + F.softplus(out)
alpha, beta = out.chunk(2, dim=1)
dist = BetaDist(alpha, beta)
return dist
class BigCritic(nn.Module):
def __init__(self, state_space_size, act_space_size, hidden_size=1024):
super().__init__()
self.fc1 = nn.Linear(state_space_size + act_space_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Linear(hidden_size, 1)
self.apply(weight_init)
def forward(self, state, action):
x = F.relu(self.fc1(torch.cat((state, action), dim=1)))
x = F.relu(self.fc2(x))
out = self.fc3(x)
return out
class BaselineActor(nn.Module):
def __init__(self, state_size, action_size, hidden_size=400):
super().__init__()
self.fc1 = nn.Linear(state_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.out = nn.Linear(hidden_size, action_size)
def forward(self, state):
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
act = torch.tanh(self.out(x))
return act
class BaselineCritic(nn.Module):
def __init__(self, state_size, action_size):
super().__init__()
self.fc1 = nn.Linear(state_size + action_size, 400)
self.fc2 = nn.Linear(400, 300)
self.out = nn.Linear(300, 1)
def forward(self, state, action):
x = torch.cat((state, action), dim=1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
val = self.out(x)
return val
class BetaDist(pyd.transformed_distribution.TransformedDistribution):
class _BetaDistTransform(pyd.transforms.Transform):
domain = pyd.constraints.real
codomain = pyd.constraints.interval(-1.0, 1.0)
def __init__(self, cache_size=1):
super().__init__(cache_size=cache_size)
def __eq__(self, other):
return isinstance(other, _BetaDistTransform)
def _inverse(self, y):
return (y.clamp(-0.99, 0.99) + 1.0) / 2.0
def _call(self, x):
return (2.0 * x) - 1.0
def log_abs_det_jacobian(self, x, y):
# return log det jacobian |dy/dx| given input and output
return torch.Tensor([math.log(2.0)]).to(x.device)
def __init__(self, alpha, beta):
self.base_dist = pyd.beta.Beta(alpha, beta)
transforms = [self._BetaDistTransform()]
super().__init__(self.base_dist, transforms)
@property
def mean(self):
mu = self.base_dist.mean
for tr in self.transforms:
mu = tr(mu)
return mu
"""
Credit for actor distribution code: https://github.com/denisyarats/pytorch_sac/blob/master/agent/actor.py
"""
class TanhTransform(pyd.transforms.Transform):
domain = pyd.constraints.real
codomain = pyd.constraints.interval(-1.0, 1.0)
bijective = True
sign = +1
def __init__(self, cache_size=1):
super().__init__(cache_size=cache_size)
@staticmethod
def atanh(x):
return 0.5 * (x.log1p() - (-x).log1p())
def __eq__(self, other):
return isinstance(other, TanhTransform)
def _call(self, x):
return x.tanh()
def _inverse(self, y):
return self.atanh(y.clamp(-0.99, 0.99))
def log_abs_det_jacobian(self, x, y):
return 2.0 * (math.log(2.0) - x - F.softplus(-2.0 * x))
class SquashedNormal(pyd.transformed_distribution.TransformedDistribution):
def __init__(self, loc, scale):
self.loc = loc
self.scale = scale
self.base_dist = pyd.Normal(loc, scale)
transforms = [TanhTransform()]
super().__init__(self.base_dist, transforms)
@property
def mean(self):
mu = self.loc
for tr in self.transforms:
mu = tr(mu)
return mu
class GracBaselineActor(nn.Module):
def __init__(self, obs_size, action_size):
super().__init__()
self.fc1 = nn.Linear(obs_size, 400)
self.fc2 = nn.Linear(400, 300)
self.fc_mean = nn.Linear(300, action_size)
self.fc_std = nn.Linear(300, action_size)
def forward(self, state, stochastic=False):
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
mean = torch.tanh(self.fc_mean(x))
std = F.softplus(self.fc_std(x)) + 1e-3
dist = pyd.Normal(mean, std)
return dist
class BaselineDiscreteActor(nn.Module):
def __init__(self, obs_shape, action_size, hidden_size=300):
super().__init__()
self.fc1 = nn.Linear(obs_shape, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.act_p = nn.Linear(hidden_size, action_size)
def forward(self, state):
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
act_p = F.softmax(self.act_p(x), dim=1)
dist = pyd.categorical.Categorical(act_p)
return dist
class BaselineDiscreteCritic(nn.Module):
def __init__(self, obs_shape, action_shape, hidden_size=300):
super().__init__()
self.fc1 = nn.Linear(obs_shape, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.out = nn.Linear(hidden_size, action_shape)
def forward(self, state):
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
vals = self.out(x)
return vals
|
from torchbenchmark.util.framework.vision.model_factory import TorchVisionModel
from torchbenchmark.tasks import COMPUTER_VISION
import torchvision.models as models
class Model(TorchVisionModel):
task = COMPUTER_VISION.CLASSIFICATION
# Train batch size: use the training batch in paper.
# Source: https://arxiv.org/pdf/1608.06993.pdf
DEFAULT_TRAIN_BSIZE = 256
DEFAULT_EVAL_BSIZE = 64
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(model_name="densenet121", test=test, device=device, jit=jit,
batch_size=batch_size, weights=models.DenseNet121_Weights.IMAGENET1K_V1,
extra_args=extra_args)
|
# Ported from pytorch example:
# https://github.com/pytorch/examples/blob/master/dcgan/main.py
from __future__ import print_function
import argparse
import os
import random
from typing import Any, Tuple
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as dset
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
from pathlib import Path
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import COMPUTER_VISION
class DCGAN:
def __init__(self, bench):
# Spatial size of training images. All images will be resized to this
# size using a transformer.
self.image_size = 64
# Number of channels in the training images. For color images this is 3
self.nc = 3
# Size of z latent vector (i.e. size of generator input)
self.nz = 100
# Size of feature maps in generator
self.ngf = 64
# Size of feature maps in discriminator
self.ndf = 64
# Number of training epochs
self.num_epochs = 5
# Learning rate for optimizers
self.lr = 0.0002
# Beta1 hyperparam for Adam optimizers
self.beta1 = 0.5
# Number of GPUs available. Use 0 for CPU mode.
self.ngpu = 1
self.device = bench.device
# custom weights initialization called on netG and netD
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0)
class Generator(nn.Module):
def __init__(self, dcgan):
super(Generator, self).__init__()
self.ngpu = dcgan.ngpu
self.main = nn.Sequential(
# input is Z, going into a convolution
nn.ConvTranspose2d( dcgan.nz, dcgan.ngf * 8, 4, 1, 0, bias=False),
nn.BatchNorm2d(dcgan.ngf * 8),
nn.ReLU(True),
# state size. (dcgan.ngf*8) x 4 x 4
nn.ConvTranspose2d(dcgan.ngf * 8, dcgan.ngf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(dcgan.ngf * 4),
nn.ReLU(True),
# state size. (dcgan.ngf*4) x 8 x 8
nn.ConvTranspose2d( dcgan.ngf * 4, dcgan.ngf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(dcgan.ngf * 2),
nn.ReLU(True),
# state size. (dcgan.ngf*2) x 16 x 16
nn.ConvTranspose2d( dcgan.ngf * 2, dcgan.ngf, 4, 2, 1, bias=False),
nn.BatchNorm2d(dcgan.ngf),
nn.ReLU(True),
# state size. (dcgan.ngf) x 32 x 32
nn.ConvTranspose2d( dcgan.ngf, dcgan.nc, 4, 2, 1, bias=False),
nn.Tanh()
# state size. (dcgan.nc) x 64 x 64
)
self.jt = None
self.jitshape = None
self.debug_print = False
def forward(self, input):
if self.debug_print:
print(input.shape)
return self.main(input)
class Discriminator(nn.Module):
def __init__(self, ncgan):
ngpu = ncgan.ngpu
nc = ncgan.nc
ndf = ncgan.ndf
super(Discriminator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(
# input is (nc) x 64 x 64
nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf) x 32 x 32
nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 2),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*2) x 16 x 16
nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 4),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*4) x 8 x 8
nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 8),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*8) x 4 x 4
nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
nn.Sigmoid()
)
self.jt = None
self.jitshape = None
def forward(self, input):
return self.main(input)
class Model(BenchmarkModel):
task = COMPUTER_VISION.GENERATION
DEFAULT_TRAIN_BSIZE = 32
DEFAULT_EVAL_BSIZE = 256
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.debug_print = False
self.root = str(Path(__file__).parent)
self.dcgan = DCGAN(self)
dcgan = self.dcgan
device = dcgan.device
ngpu = dcgan.ngpu
nz = dcgan.nz
lr = dcgan.lr
beta1 = dcgan.beta1
num_epochs = dcgan.num_epochs
# Create the generator
self.netG = Generator(dcgan).to(device)
# Handle multi-gpu if desired
if (dcgan.device == 'cuda') and (ngpu > 1):
self.netG = nn.DataParallel(self.netG, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights
# to mean=0, stdev=0.2.
self.netG.apply(weights_init)
if self.debug_print:
# Print the model
print(self.netG)
# Create the Discriminator
netD = Discriminator(dcgan).to(device)
# Handle multi-gpu if desired
if (dcgan.device == 'cuda') and (ngpu > 1):
netD = nn.DataParallel(self.netD, list(range(ngpu)))
# Apply the weights_init function to randomly initialize all weights
# to mean=0, stdev=0.2.
netD.apply(weights_init)
if self.debug_print:
# Print the model
print(netD)
# Initialize BCELoss function
self.criterion = nn.BCELoss()
# Create batch of latent vectors that we will use to visualize
# the progression of the generator
self.fixed_noise = torch.randn(64, nz, 1, 1, device=device)
# Establish convention for real and fake labels during training
self.real_label = 1.
self.fake_label = 0.
# Random values as surrogate for batch of photos
self.exmaple_inputs = torch.randn(self.batch_size, 3, 64, 64, device=self.device)
self.model = netD
if test == "train":
# Setup Adam optimizers for both G and D
self.optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
self.optimizerG = optim.Adam(self.netG.parameters(), lr=lr, betas=(beta1, 0.999))
elif test == "eval":
# inference would just run descriminator so thats what we'll do too.
self.inference_just_descriminator = True
if False == self.inference_just_descriminator:
self.eval_noise = torch.randn(self.batch_size, nz, 1, 1, device=self.device)
def jit_callback(self):
assert self.jit, "Calling JIT callback without specifying the JIT option."
self.model = torch.jit.trace(self.model,(self.exmaple_inputs,))
if self.test == "eval" and False == self.inference_just_descriminator:
self.netG = torch.jit.trace(self.netG,(self.eval_noise,))
def get_module(self):
return self.model, (self.exmaple_inputs,)
def eval(self):
if False == self.inference_just_descriminator:
# Generate fake image batch with G
self.eval_fake = self.netG(self.eval_noise)
# Since we just updated D, perform another forward pass of all-fake batch through D
output = self.model(self.exmaple_inputs).view(-1)
return (output, )
def train(self):
# Training Loop
# Lists to keep track of progress
img_list = []
iters = 0
dcgan = self.dcgan
device = dcgan.device
num_epochs = dcgan.num_epochs
num_train_batch = 1
lr = dcgan.lr
nz = dcgan.nz
beta1 = dcgan.beta1
netD = self.model
netG = self.netG
criterion = self.criterion
optimizerD = self.optimizerD
optimizerG = self.optimizerG
real_label = self.real_label
fake_label = self.fake_label
benchmark_pic = self.exmaple_inputs
# For each epoch
for epoch in range(num_epochs):
for i in range(num_train_batch):
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
## Train with all-real batch
netD.zero_grad()
# Format batch
real_cpu = benchmark_pic
b_size = real_cpu.size(0)
label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
# Forward pass real batch through D
output = netD(real_cpu).view(-1)
# Calculate loss on all-real batch
errD_real = criterion(output, label)
# Calculate gradients for D in backward pass
errD_real.backward()
D_x = output.mean().item()
## Train with all-fake batch
# Generate batch of latent vectors
noise = torch.randn(b_size, nz, 1, 1, device=device)
# Generate fake image batch with G
fake = netG(noise)
label.fill_(fake_label)
# Classify all fake batch with D
output = netD(fake.detach()).view(-1)
# Calculate D's loss on the all-fake batch
errD_fake = criterion(output, label)
# Calculate the gradients for this batch, accumulated (summed) with previous gradients
errD_fake.backward()
D_G_z1 = output.mean().item()
# Compute error of D as sum over the fake and the real batches
errD = errD_real + errD_fake
# Update D
optimizerD.step()
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
netG.zero_grad()
label.fill_(real_label) # fake labels are real for generator cost
# Since we just updated D, perform another forward pass of all-fake batch through D
output = netD(fake).view(-1)
# Calculate G's loss based on this output
errG = criterion(output, label)
# Calculate gradients for G
errG.backward()
D_G_z2 = output.mean().item()
# Update G
optimizerG.step()
# This model has TWO optimizers! Try returning both.
def get_optimizer(self):
return (self.optimizerD, self.optimizerG)
# `optimizer` has type Tuple but we want this function to override the parent's
# so keep the name and schema the same.
def set_optimizer(self, optimizer) -> None:
self.optimizerD, self.optimizerG = optimizer
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
import os
from torchbenchmark.tasks import COMPUTER_VISION
from torchbenchmark.util.framework.detectron2.model_factory import Detectron2Model
MODEL_NAME = os.path.basename(os.path.dirname(__file__))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
class Model(Detectron2Model):
task = COMPUTER_VISION.DETECTION
model_file = os.path.join(MODEL_DIR, ".data", f"{MODEL_NAME}.pkl")
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(variant="COCO-Detection/faster_rcnn_R_50_DC5_1x.yaml", test=test, device=device,
jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import os
from torchbenchmark.util.framework.detectron2 import install_detectron2
MODEL_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
if __name__ == '__main__':
install_detectron2(MODEL_NAME, MODEL_DIR)
|
import os
from torchbenchmark.tasks import COMPUTER_VISION
from torchbenchmark.util.framework.detectron2.model_factory import Detectron2Model
MODEL_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
class Model(Detectron2Model):
task = COMPUTER_VISION.SEGMENTATION
model_file = os.path.join(MODEL_DIR, ".data", f"{MODEL_NAME}.pkl")
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(variant="COCO-InstanceSegmentation/mask_rcnn_R_50_C4_1x.yaml", test=test, device=device,
jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import os
from torchbenchmark.util.framework.detectron2 import install_detectron2
MODEL_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.abspath(os.path.dirname(__file__))
if __name__ == '__main__':
install_detectron2(MODEL_NAME, MODEL_DIR)
|
from torchbenchmark.util.framework.vision.model_factory import TorchVisionModel
from torchbenchmark.tasks import COMPUTER_VISION
import torchvision.models as models
class Model(TorchVisionModel):
task = COMPUTER_VISION.CLASSIFICATION
DEFAULT_TRAIN_BSIZE = 128
DEFAULT_EVAL_BSIZE = 64
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(model_name="shufflenet_v2_x1_0", test=test, device=device, jit=jit,
batch_size=batch_size, weights=models.ShuffleNet_V2_X1_0_Weights.IMAGENET1K_V1,
extra_args=extra_args)
|
import torch
def get_drhodT(salt, temp, p):
rho0 = 1024.0
z0 = 0.0
theta0 = 283.0 - 273.15
grav = 9.81
betaT = 1.67e-4
betaTs = 1e-5
gammas = 1.1e-8
zz = -p - z0
thetas = temp - theta0
return -(betaTs * thetas + betaT * (1 - gammas * grav * zz * rho0)) * rho0
def get_drhodS(salt, temp, p):
betaS = 0.78e-3
rho0 = 1024.0
return betaS * rho0 * torch.ones_like(temp)
def dm_taper(sx):
"""
tapering function for isopycnal slopes
"""
iso_slopec = 1e-3
iso_dslope = 1e-3
return 0.5 * (1.0 + torch.tanh((-torch.abs(sx) + iso_slopec) / iso_dslope))
def isoneutral_diffusion_pre(
maskT,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
salt,
temp,
zt,
K_iso,
K_11,
K_22,
K_33,
Ai_ez,
Ai_nz,
Ai_bx,
Ai_by,
):
"""
Isopycnal diffusion for tracer
following functional formulation by Griffies et al
Code adopted from MOM2.1
"""
epsln = 1e-20
K_iso_steep = 50.0
tau = 0
device = K_11.device
dTdx = torch.zeros_like(K_11)
dSdx = torch.zeros_like(K_11)
dTdy = torch.zeros_like(K_11)
dSdy = torch.zeros_like(K_11)
dTdz = torch.zeros_like(K_11)
dSdz = torch.zeros_like(K_11)
"""
drho_dt and drho_ds at centers of T cells
"""
drdT = maskT * get_drhodT(salt[:, :, :, tau], temp[:, :, :, tau], torch.abs(zt))
drdS = maskT * get_drhodS(salt[:, :, :, tau], temp[:, :, :, tau], torch.abs(zt))
"""
gradients at top face of T cells
"""
dTdz[:, :, :-1] = (
maskW[:, :, :-1]
* (temp[:, :, 1:, tau] - temp[:, :, :-1, tau])
/ dzw[None, None, :-1]
)
dSdz[:, :, :-1] = (
maskW[:, :, :-1]
* (salt[:, :, 1:, tau] - salt[:, :, :-1, tau])
/ dzw[None, None, :-1]
)
"""
gradients at eastern face of T cells
"""
dTdx[:-1, :, :] = (
maskU[:-1, :, :]
* (temp[1:, :, :, tau] - temp[:-1, :, :, tau])
/ (dxu[:-1, None, None] * cost[None, :, None])
)
dSdx[:-1, :, :] = (
maskU[:-1, :, :]
* (salt[1:, :, :, tau] - salt[:-1, :, :, tau])
/ (dxu[:-1, None, None] * cost[None, :, None])
)
"""
gradients at northern face of T cells
"""
dTdy[:, :-1, :] = (
maskV[:, :-1, :]
* (temp[:, 1:, :, tau] - temp[:, :-1, :, tau])
/ dyu[None, :-1, None]
)
dSdy[:, :-1, :] = (
maskV[:, :-1, :]
* (salt[:, 1:, :, tau] - salt[:, :-1, :, tau])
/ dyu[None, :-1, None]
)
"""
Compute Ai_ez and K11 on center of east face of T cell.
"""
diffloc = torch.zeros_like(K_11)
diffloc[1:-2, 2:-2, 1:] = 0.25 * (
K_iso[1:-2, 2:-2, 1:]
+ K_iso[1:-2, 2:-2, :-1]
+ K_iso[2:-1, 2:-2, 1:]
+ K_iso[2:-1, 2:-2, :-1]
)
diffloc[1:-2, 2:-2, 0] = 0.5 * (K_iso[1:-2, 2:-2, 0] + K_iso[2:-1, 2:-2, 0])
sumz = torch.zeros_like(K_11)[1:-2, 2:-2]
for kr in range(2):
ki = 0 if kr == 1 else 1
if kr == 1:
su = K_11.shape[2]
else:
su = K_11.shape[2] - 1
for ip in range(2):
drodxe = (
drdT[1 + ip : -2 + ip, 2:-2, ki:] * dTdx[1:-2, 2:-2, ki:]
+ drdS[1 + ip : -2 + ip, 2:-2, ki:] * dSdx[1:-2, 2:-2, ki:]
)
drodze = (
drdT[1 + ip : -2 + ip, 2:-2, ki:] * dTdz[1 + ip : -2 + ip, 2:-2, :su]
+ drdS[1 + ip : -2 + ip, 2:-2, ki:] * dSdz[1 + ip : -2 + ip, 2:-2, :su]
)
sxe = -drodxe / (
torch.min(drodze, torch.tensor([0.0], device=device)) - epsln
)
taper = dm_taper(sxe)
sumz[:, :, ki:] += (
dzw[None, None, :su]
* maskU[1:-2, 2:-2, ki:]
* torch.max(
torch.tensor([K_iso_steep], device=device),
diffloc[1:-2, 2:-2, ki:] * taper,
)
)
Ai_ez[1:-2, 2:-2, ki:, ip, kr] = taper * sxe * maskU[1:-2, 2:-2, ki:]
K_11[1:-2, 2:-2, :] = sumz / (4.0 * dzt[None, None, :])
"""
Compute Ai_nz and K_22 on center of north face of T cell.
"""
diffloc[...] = 0
diffloc[2:-2, 1:-2, 1:] = 0.25 * (
K_iso[2:-2, 1:-2, 1:]
+ K_iso[2:-2, 1:-2, :-1]
+ K_iso[2:-2, 2:-1, 1:]
+ K_iso[2:-2, 2:-1, :-1]
)
diffloc[2:-2, 1:-2, 0] = 0.5 * (K_iso[2:-2, 1:-2, 0] + K_iso[2:-2, 2:-1, 0])
sumz = torch.zeros_like(K_11)[2:-2, 1:-2]
for kr in range(2):
ki = 0 if kr == 1 else 1
if kr == 1:
su = K_11.shape[2]
else:
su = K_11.shape[2] - 1
for jp in range(2):
drodyn = (
drdT[2:-2, 1 + jp : -2 + jp, ki:] * dTdy[2:-2, 1:-2, ki:]
+ drdS[2:-2, 1 + jp : -2 + jp, ki:] * dSdy[2:-2, 1:-2, ki:]
)
drodzn = (
drdT[2:-2, 1 + jp : -2 + jp, ki:] * dTdz[2:-2, 1 + jp : -2 + jp, :su]
+ drdS[2:-2, 1 + jp : -2 + jp, ki:] * dSdz[2:-2, 1 + jp : -2 + jp, :su]
)
syn = -drodyn / (
torch.min(torch.tensor([0.0], device=device), drodzn) - epsln
)
taper = dm_taper(syn)
sumz[:, :, ki:] += (
dzw[None, None, :su]
* maskV[2:-2, 1:-2, ki:]
* torch.max(
torch.tensor([K_iso_steep], device=device),
diffloc[2:-2, 1:-2, ki:] * taper,
)
)
Ai_nz[2:-2, 1:-2, ki:, jp, kr] = taper * syn * maskV[2:-2, 1:-2, ki:]
K_22[2:-2, 1:-2, :] = sumz / (4.0 * dzt[None, None, :])
"""
compute Ai_bx, Ai_by and K33 on top face of T cell.
"""
sumx = torch.zeros_like(K_11)[2:-2, 2:-2, :-1]
sumy = torch.zeros_like(K_11)[2:-2, 2:-2, :-1]
for kr in range(2):
if kr == 1:
sl = 1
su = K_11.shape[2]
else:
sl = 0
su = K_11.shape[2] - 1
drodzb = (
drdT[2:-2, 2:-2, sl:su] * dTdz[2:-2, 2:-2, :-1]
+ drdS[2:-2, 2:-2, sl:su] * dSdz[2:-2, 2:-2, :-1]
)
# eastward slopes at the top of T cells
for ip in range(2):
drodxb = (
drdT[2:-2, 2:-2, sl:su] * dTdx[1 + ip : -3 + ip, 2:-2, sl:su]
+ drdS[2:-2, 2:-2, sl:su] * dSdx[1 + ip : -3 + ip, 2:-2, sl:su]
)
sxb = -drodxb / (
torch.min(torch.tensor([0.0], device=device), drodzb) - epsln
)
taper = dm_taper(sxb)
sumx += (
dxu[1 + ip : -3 + ip, None, None]
* K_iso[2:-2, 2:-2, :-1]
* taper
* sxb ** 2
* maskW[2:-2, 2:-2, :-1]
)
Ai_bx[2:-2, 2:-2, :-1, ip, kr] = taper * sxb * maskW[2:-2, 2:-2, :-1]
# northward slopes at the top of T cells
for jp in range(2):
facty = cosu[1 + jp : -3 + jp] * dyu[1 + jp : -3 + jp]
drodyb = (
drdT[2:-2, 2:-2, sl:su] * dTdy[2:-2, 1 + jp : -3 + jp, sl:su]
+ drdS[2:-2, 2:-2, sl:su] * dSdy[2:-2, 1 + jp : -3 + jp, sl:su]
)
syb = -drodyb / (
torch.min(torch.tensor([0.0], device=device), drodzb) - epsln
)
taper = dm_taper(syb)
sumy += (
facty[None, :, None]
* K_iso[2:-2, 2:-2, :-1]
* taper
* syb ** 2
* maskW[2:-2, 2:-2, :-1]
)
Ai_by[2:-2, 2:-2, :-1, jp, kr] = taper * syb * maskW[2:-2, 2:-2, :-1]
K_33[2:-2, 2:-2, :-1] = sumx / (4 * dxt[2:-2, None, None]) + sumy / (
4 * dyt[None, 2:-2, None] * cost[None, 2:-2, None]
)
K_33[2:-2, 2:-2, -1] = 0.0
return K_11, K_22, K_33, Ai_ez, Ai_nz, Ai_bx, Ai_by
def prepare_inputs(*inputs, device):
out = [
torch.as_tensor(a, device=device) for a in inputs
]
if device == "gpu":
torch.cuda.synchronize()
return out
def run(*inputs, device="cpu"):
with torch.no_grad():
outputs = isoneutral_diffusion_pre(*inputs)
if device == "gpu":
torch.cuda.synchronize()
return outputs
|
import torch
from . import isoneutral_pytorch
from torchbenchmark.tasks import OTHER
from ...util.model import BenchmarkModel
from typing import Tuple
def _generate_inputs(size):
import math
import numpy as np
np.random.seed(17)
shape = (
math.ceil(2 * size ** (1 / 3)),
math.ceil(2 * size ** (1 / 3)),
math.ceil(0.25 * size ** (1 / 3)),
)
# masks
maskT, maskU, maskV, maskW = (
(np.random.rand(*shape) < 0.8).astype("float64") for _ in range(4)
)
# 1d arrays
dxt, dxu = (np.random.randn(shape[0]) for _ in range(2))
dyt, dyu = (np.random.randn(shape[1]) for _ in range(2))
dzt, dzw, zt = (np.random.randn(shape[2]) for _ in range(3))
cost, cosu = (np.random.randn(shape[1]) for _ in range(2))
# 3d arrays
K_iso, K_iso_steep, K_11, K_22, K_33 = (np.random.randn(*shape) for _ in range(5))
# 4d arrays
salt, temp = (np.random.randn(*shape, 3) for _ in range(2))
# 5d arrays
Ai_ez, Ai_nz, Ai_bx, Ai_by = (np.zeros((*shape, 2, 2)) for _ in range(4))
return (
maskT,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
salt,
temp,
zt,
K_iso,
K_11,
K_22,
K_33,
Ai_ez,
Ai_nz,
Ai_bx,
Ai_by,
)
class IsoneutralMixing(torch.nn.Module):
def __init__(self):
super(IsoneutralMixing, self).__init__()
def forward(
self,
maskT,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
salt,
temp,
zt,
K_iso,
K_11,
K_22,
K_33,
Ai_ez,
Ai_nz,
Ai_bx,
Ai_by,
):
return isoneutral_pytorch.isoneutral_diffusion_pre(
maskT,
maskU,
maskV,
maskW,
dxt,
dxu,
dyt,
dyu,
dzt,
dzw,
cost,
cosu,
salt,
temp,
zt,
K_iso,
K_11,
K_22,
K_33,
Ai_ez,
Ai_nz,
Ai_bx,
Ai_by,
)
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
# Original input size: [2 ** i for i in range(12, 23, 2)]
# Source: https://github.com/dionhaefner/pyhpc-benchmarks/blob/650ecc650e394df829944ffcf09e9d646ec69691/run.py#L25
# Pick data-point when i = 20, size = 1048576
DEFAULT_EVAL_BSIZE = 1048576
CANNOT_SET_CUSTOM_OPTIMIZER = True
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = IsoneutralMixing().to(device=device)
input_size = self.batch_size
raw_inputs = _generate_inputs(input_size)
if hasattr(isoneutral_pytorch, "prepare_inputs"):
inputs = isoneutral_pytorch.prepare_inputs(*raw_inputs, device=device)
self.example_inputs = inputs
def get_module(self):
return self.model, self.example_inputs
def train(self):
raise NotImplementedError("Training not supported")
def eval(self) -> Tuple[torch.Tensor]:
model, example_inputs = self.get_module()
with torch.no_grad():
out = model(*example_inputs)
return out
|
if __name__ == "__main__":
pass
|
"""
pytorch_struct model, Unsupervised CFG task
https://github.com/harvardnlp/pytorch-struct/blob/master/notebooks/Unsupervised_CFG.ipynb
"""
import os
import pytest
import torchtext
import numpy as np
import torch, random
import torch_struct
from torch_struct import SentCFG
from .networks.NeuralCFG import NeuralCFG
from torchbenchmark.util.torchtext_legacy.field import Field
from torchbenchmark.util.torchtext_legacy.datasets import UDPOS
from torchbenchmark.util.torchtext_legacy.iterator import BucketIterator
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import OTHER
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = False
def _prefetch(loader, device, limit=10):
data = []
for _, ex in zip(range(limit), loader):
words, lengths = ex.word
words = words.long()
words = words.to(device).transpose(0, 1)
data.append((words, lengths))
return data
def TokenBucket(
train, batch_size, device, key=lambda x: max(len(x.word[0]), 5)
):
def batch_size_fn(x, _, size):
return size + key(x)
return BucketIterator(
train,
train=True,
sort=False,
sort_within_batch=True,
shuffle=True,
batch_size=batch_size,
sort_key=lambda x: key(x),
repeat=True,
batch_size_fn=batch_size_fn,
device=device,
)
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
# Original train batch size: 200
# Source: https://github.com/harvardnlp/pytorch-struct/blob/f4e374e894b94a9411fb3d2dfb44201a18e37b26/notebooks/Unsupervised_CFG.ipynb
DEFAULT_TRAIN_BSIZE = 200
NUM_OF_BATCHES = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
WORD = Field(include_lengths=True)
UD_TAG = Field(init_token="<bos>", eos_token="<eos>", include_lengths=True)
train, val, test = UDPOS.splits(
fields=(('word', WORD), ('udtag', UD_TAG), (None, None)),
filter_pred=lambda ex: 5 < len(ex.word) < 30
)
WORD.build_vocab(train.word, min_freq=3)
UD_TAG.build_vocab(train.udtag)
self.iter = TokenBucket(train, batch_size=self.batch_size,
device=self.device)
# Build model
H = 256
T = 30
NT = 30
self.model = NeuralCFG(len(WORD.vocab), T, NT, H)
self.model.to(device=device)
self.opt = torch.optim.Adam(self.model.parameters(), lr=0.001, betas=[0.75, 0.999])
self.example_inputs = _prefetch(self.iter, self.device)
def get_module(self):
for words, _ in self.example_inputs:
return self.model, (words, )
def train(self):
for _, (words, lengths) in zip(range(self.NUM_OF_BATCHES), self.example_inputs):
losses = []
self.opt.zero_grad()
params = self.model(words)
dist = SentCFG(params, lengths=lengths)
loss = dist.partition.mean()
(-loss).backward()
losses.append(loss.detach())
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 3.0)
self.opt.step()
def eval(self):
raise NotImplementedError("Eval is not supported by this model")
def cuda_sync(func, sync=False):
func()
if sync:
torch.cuda.synchronize()
@pytest.mark.parametrize('jit', [True, False], ids=['jit', 'no-jit'])
@pytest.mark.parametrize('device', ['cpu', 'cuda'])
class TestBench():
def test_train(self, benchmark, device, jit):
m = Model(device=device, jit=jit)
benchmark(cuda_sync, m.train, device=='cuda')
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
import torch
import torch.nn as nn
class Res(nn.Module):
def __init__(self, H):
super().__init__()
self.u1 = nn.Linear(H, H)
self.u2 = nn.Linear(H, H)
self.v1 = nn.Linear(H, H)
self.v2 = nn.Linear(H, H)
self.w = nn.Linear(H, H)
def forward(self, y):
y = self.w(y)
y = y + torch.relu(self.v1(torch.relu(self.u1(y))))
return y + torch.relu(self.v2(torch.relu(self.u2(y))))
class NeuralCFG(torch.nn.Module):
"""
NeuralCFG From Kim et al
"""
def __init__(self, V, T, NT, H):
super().__init__()
self.NT = NT
self.V = V
self.T = T
self.word_emb = nn.Parameter(torch.Tensor(V, H))
self.term_emb = nn.Parameter(torch.Tensor(T, H))
self.nonterm_emb = nn.Parameter(torch.Tensor(NT, H))
self.nonterm_emb_c = nn.Parameter(torch.Tensor(NT + T, NT + T, H))
self.root_emb = nn.Parameter(torch.Tensor(NT, H))
self.s_emb = nn.Parameter(torch.Tensor(1, H))
self.mlp1 = Res(H)
self.mlp2 = Res(H)
for p in self.parameters():
if p.dim() > 1:
torch.nn.init.xavier_uniform_(p)
def forward(self, input):
T, NT = self.T, self.NT
def terms(words):
b, n = input.shape[:2]
term_prob = (
torch.einsum("vh,th->tv", self.word_emb, self.mlp1(self.term_emb))
.log_softmax(-1)
.unsqueeze(0)
.unsqueeze(0)
.expand(b, n, self.T, self.V)
)
indices = input.unsqueeze(2).expand(b, n, self.T).unsqueeze(3)
term_prob = torch.gather(term_prob, 3, indices).squeeze(3)
return term_prob
def rules(b):
return (
torch.einsum("sh,tuh->stu", self.nonterm_emb, self.nonterm_emb_c)
.view(NT, -1)
.log_softmax(-1)
.view(1, NT, NT + T, NT + T)
.expand(b, NT, NT + T, NT + T)
)
def roots(b):
return (
torch.einsum("ah,th->t", self.s_emb, self.mlp2(self.root_emb))
.log_softmax(-1)
.view(1, NT)
.expand(b, NT)
)
batch = input.shape[0]
return terms(input), rules(batch), roots(batch)
|
# This example was adapated from https://github.com/muhrin/milad
# It is licensed under the GLPv3 license. You can find a copy of it
# here: https://www.gnu.org/licenses/gpl-3.0.en.html .
import torch
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
from functorch import vmap, jacrev
from typing import Tuple
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import OTHER
sigma = 0.5
epsilon = 4.
def lennard_jones(r):
return epsilon * ((sigma / r)**12 - (sigma / r)**6)
def lennard_jones_force(r):
"""Get magnitude of LJ force"""
return -epsilon * ((-12 * sigma**12 / r**13) + (6 * sigma**6 / r**7))
def make_prediction(model, drs):
norms = torch.norm(drs, dim=1).reshape(-1, 1)
energies = model(norms)
network_derivs = vmap(jacrev(model))(norms).squeeze(-1)
forces = -network_derivs * drs / norms
return energies, forces
def loss_fn(energies, forces, predicted_energies, predicted_forces):
return F.mse_loss(energies, predicted_energies) + 0.01 * F.mse_loss(forces, predicted_forces) / 3
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
DEFAULT_TRAIN_BSIZE = 1000
DEFAULT_EVAL_BSIZE = 1000
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = nn.Sequential(
nn.Linear(1, 16),
nn.Tanh(),
nn.Linear(16, 16),
nn.Tanh(),
nn.Linear(16, 16),
nn.Tanh(),
nn.Linear(16, 16),
nn.Tanh(),
nn.Linear(16, 1)
)
self.model = self.model.to(device)
r = torch.linspace(0.5, 2 * sigma, steps=self.batch_size)
# Create a bunch of vectors that point along positive-x.
# These are the dummy inputs to the model.
self.drs = torch.outer(r, torch.tensor([1.0, 0, 0])).to(device=device)
# Generate some dummy targets based off of some interpretation of the lennard_jones force.
norms = torch.norm(self.drs, dim=1).reshape(-1, 1)
self.norms = norms
# Create training energies
self.training_energies = torch.stack(list(map(lennard_jones, norms))).reshape(-1, 1)
# Create forces with random direction vectors
self.training_forces = torch.stack([
force * dr for force, dr in zip(map(lennard_jones_force, norms), self.drs)
])
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-3)
def get_module(self):
return self.model, (self.norms, )
def train(self):
model = self.model
optimizer = self.optimizer
model.train()
optimizer.zero_grad()
energies, forces = make_prediction(model, self.drs)
loss = loss_fn(self.training_energies, self.training_forces, energies, forces)
loss.backward()
optimizer.step()
def eval(self) -> Tuple[torch.Tensor]:
model = self.model
model.eval()
with torch.no_grad():
out = make_prediction(model, self.drs)
return out
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
from torchbenchmark.tasks import NLP
from torchbenchmark.util.framework.huggingface.model_factory import HuggingFaceModel
class Model(HuggingFaceModel):
task = NLP.LANGUAGE_MODELING
DEFAULT_TRAIN_BSIZE = 4
DEFAULT_EVAL_BSIZE = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(name="hf_Bert_large", test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
|
import subprocess
import sys
import os
from torchbenchmark.util.framework.huggingface.patch_hf import patch_transformers, cache_model
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
patch_transformers()
model_name = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
cache_model(model_name)
|
"""
fastNLP model (TorchBenchmark Version)
This model resembles the "BertEmedding Q&A" task in [fastNLP Tutorial](https://fastnlp.readthedocs.io/zh/latest/tutorials/extend_1_bert_embedding.html).
Input data simulates [CMRC2018 dataset](https://ymcui.com/cmrc2018/).
The program runs only for benchmark purposes and doesn't provide correctness results.
"""
import logging
from typing import Tuple
import torch
import random
import inspect
import numpy as np
from fastNLP.embeddings import BertEmbedding
from fastNLP.models import BertForQuestionAnswering
from fastNLP.core.callback import CallbackManager
from fastNLP.core.batch import DataSetIter
from fastNLP.core.losses import CMRC2018Loss
from fastNLP.core.metrics import CMRC2018Metric
from fastNLP.io.pipe.qa import CMRC2018BertPipe
from fastNLP import WarmupCallback, GradientClipCallback
from fastNLP.core.optimizer import AdamW
from fastNLP.core import logger
# Import CMRC2018 data generator
from .cmrc2018_simulator import generate_inputs
from .cmrc2018_simulator import CMRC2018_DIR, CMRC2018_CONFIG_DIR
# TorchBench imports
from torchbenchmark.util.model import BenchmarkModel
from torchbenchmark.tasks import NLP
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
logger.setLevel(logging.WARNING)
class Model(BenchmarkModel):
task = NLP.LANGUAGE_MODELING
# Use the train batch size from the original CMRC2018 Q&A task
# Source: https://fastnlp.readthedocs.io/zh/latest/tutorials/extend_1_bert_embedding.html
DEFAULT_TRAIN_BSIZE = 6
DEFAULT_EVAL_BSIZE = 1
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.input_dir = CMRC2018_DIR
# Generate input data files
# FastNLP loader requires both train and eval files, so we need to generate both of them
if test == "train":
generate_inputs(train_batch_size=self.batch_size, eval_batch_size=self.DEFAULT_EVAL_BSIZE)
elif test == "eval":
generate_inputs(train_batch_size=self.DEFAULT_TRAIN_BSIZE, eval_batch_size=self.batch_size)
data_bundle = CMRC2018BertPipe().process_from_file(paths=self.input_dir)
data_bundle.rename_field('chars', 'words')
self.embed = BertEmbedding(data_bundle.get_vocab('words'),
model_dir_or_name=CMRC2018_CONFIG_DIR,
requires_grad=True,
include_cls_sep=False, auto_truncate=True,
dropout=0.5, word_dropout=0.01)
self.model = self._move_model_to_device(BertForQuestionAnswering(self.embed), device=device)
if self._model_contains_inner_module(self.model):
self._forward_func = self.model.module.forward
else:
self._forward_func = self.model.forward
# Do not spawn new processes on small scale of data
self.num_workers = 0
if self.test == "train":
self.model.train()
self.trainer = self.model
self.train_data = data_bundle.get_dataset('train')
self.data = self.train_data
self.losser = CMRC2018Loss()
self.metrics = CMRC2018Metric()
self.update_every = 10
wm_callback = WarmupCallback(schedule='linear')
gc_callback = GradientClipCallback(clip_value=1, clip_type='norm')
callbacks = [wm_callback, gc_callback]
self.optimizer = AdamW(self.model.parameters(), lr=5e-5)
self.callback_manager = CallbackManager(env={"trainer":self}, callbacks=callbacks)
elif self.test == "eval":
self.model.eval()
self.data = data_bundle.get_dataset('dev')
example_inputs = DataSetIter(dataset=self.data,
batch_size=self.batch_size,
sampler=None,
num_workers=self.num_workers, drop_last=False)
self.example_inputs = self._prefetch(example_inputs)
def get_module(self):
batch_x, _batch_y = list(self.example_inputs)[0]
return self.model, (batch_x["words"], )
# Sliced version of fastNLP.Tester._test()
def eval(self) -> Tuple[torch.Tensor]:
self._mode(self.model, is_test=True)
self._predict_func = self.model.forward
with torch.no_grad():
for batch_x, _batch_y in self.example_inputs:
pred_dict = self._data_forward(self._predict_func, batch_x)
# return a tuple of Tensors
return (pred_dict['pred_start'], pred_dict['pred_end'] )
# Sliced version of fastNLP.Trainer._train()
def train(self):
self.step = 0
self.n_epochs = 1
self._mode(self.model, is_test=False)
self.callback_manager.on_train_begin()
for _epoch in range(self.n_epochs):
self.callback_manager.on_epoch_begin()
for batch_x, batch_y in self.example_inputs:
self.step += 1
prediction = self._data_forward(self.model, batch_x)
self.callback_manager.on_loss_begin(batch_y, prediction)
loss = self._compute_loss(prediction, batch_y).mean()
self.callback_manager.on_backward_begin(loss)
self._grad_backward(loss)
self.callback_manager.on_backward_end()
self._update()
self.callback_manager.on_step_end()
self.callback_manager.on_batch_end()
self.callback_manager.on_epoch_end()
self.callback_manager.on_train_end()
def _prefetch(self, example_inputs):
prefetched_data = []
for batch_x, batch_y in example_inputs:
self._move_dict_value_to_device(batch_x, batch_y, device=self.device)
prefetched_data.append((batch_x, batch_y))
return prefetched_data
# Helper functions
def _build_args(self, func, **kwargs):
spect = inspect.getfullargspec(func)
if spect.varkw is not None:
return kwargs
needed_args = set(spect.args)
defaults = []
if spect.defaults is not None:
defaults = [arg for arg in spect.defaults]
start_idx = len(spect.args) - len(defaults)
output = {name: default for name, default in zip(spect.args[start_idx:], defaults)}
output.update({name: val for name, val in kwargs.items() if name in needed_args})
return output
def _move_dict_value_to_device(self, *args, device, non_blocking=False):
for arg in args:
if isinstance(arg, dict):
for key, value in arg.items():
if isinstance(value, torch.Tensor):
arg[key] = value.to(device, non_blocking=non_blocking)
else:
raise TypeError("Only support `dict` type right now.")
def _model_contains_inner_module(self, model):
if isinstance(model, torch.nn.Module):
if isinstance(model, (torch.nn.DataParallel, torch.nn.parallel.DistributedDataParallel)):
return True
return False
def _move_model_to_device(self, model, device):
model = model.to(device)
return model
def _mode(self, model, is_test=False):
r"""Train mode or Test mode. This is for PyTorch currently.
:param model: a PyTorch model
:param bool is_test: whether in test mode or not.
"""
if is_test:
model.eval()
else:
model.train()
def _update(self):
r"""Perform weight update on a model.
"""
if self.step % self.update_every == 0:
self.optimizer.step()
def _data_forward(self, network, x):
x = self._build_args(self._forward_func, **x)
y = network(**x)
if not isinstance(y, dict):
raise TypeError(
f"The return value of {_get_func_signature(self._forward_func)} should be dict, got {type(y)}.")
return y
def _grad_backward(self, loss):
r"""Compute gradient with link rules.
:param loss: a scalar where back-prop starts
For PyTorch, just do "loss.backward()"
"""
if (self.step-1) % self.update_every == 0:
self.model.zero_grad()
loss.backward()
def _compute_loss(self, predict, truth):
r"""Compute loss given prediction and ground truth.
:param predict: prediction dict, produced by model.forward
:param truth: ground truth dict, produced by batch_y
:return: a scalar
"""
return self.losser(predict, truth)
def get_optimizer(self):
r"""Gets the optimizer if initiated"""
if hasattr(self, "optimizer"):
return self.optimizer
return None
def set_optimizer(self, optimizer) -> None:
r"""Sets the optimizer regardless of whether it's been initiated"""
self.optimizer = optimizer
|
import subprocess
import os
import sys
import patch
def patch_fastnlp():
import fastNLP
current_dir = os.path.dirname(os.path.abspath(__file__))
patch_file = os.path.join(current_dir, "fastnlp.patch")
fastNLP_dir = os.path.dirname(fastNLP.__file__)
fastNLP_target_file = os.path.join(fastNLP_dir, "embeddings", "bert_embedding.py")
p = patch.fromfile(patch_file)
if not p.apply(strip=1, root=fastNLP_dir):
print("Failed to patch fastNLP. Exit.")
exit(1)
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
patch_fastnlp()
|
"""
Generator of a simulated CMRC2018 dataset.
Use random Chinese characters with the same length as the original dataset.
"""
import os
import pathlib
import json
import random
TRAIN_NUM_BATCH = 1
EVAL_NUM_BATCH = 1
CMRC2018_TRAIN_SPEC = {
# Original
# "data_size": 2403,
# Benchmark
"data_size": 6, # placeholder, will be replaced by the true batch size
"title_length": 5,
"paragraph_size": 1,
"context_length": 456,
"qas_size": 5,
"query_length": 15,
"answers_size": 1,
"answers_length": 7
}
CMRC2018_DEV_SPEC = {
# Original
# "data_size": 848,
# Benchmark
"data_size": 1, # placeholder, will be replaced by the true batch size
"title_length": 4,
"paragraph_size": 1,
"context_length": 455,
"qas_size": 4,
"query_length": 15,
"answers_size": 3,
"answers_length": 7
}
CMRC2018_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".data", "cmrc2018-sim")
CMRC2018_CONFIG_DIR = os.path.join(CMRC2018_DIR, "config")
CMRC2018_TRAIN_SIM = os.path.join(CMRC2018_DIR, "train.json")
CMRC2018_DEV_SIM = os.path.join(CMRC2018_DIR, "dev.json")
CMRC2018_VOCAB_SIM = os.path.join(CMRC2018_CONFIG_DIR, "vocab.txt")
CMRC2018_BERT_CONFIG = os.path.join(CMRC2018_CONFIG_DIR, "bert_config.json")
VOCAB_SET = set()
# Generate random Chinese string with length l
def _GBK2312(l):
head = 0xd7
while head == 0xd7:
head = random.randint(0xb0, 0xf7)
body = random.randint(0xa1, 0xfe)
val = f'{head:x} {body:x}'
s = bytes.fromhex(val).decode('gb2312')
VOCAB_SET.add(s)
if l == 0:
return s
else:
return s + _GBK2312(l-1)
def _generate_cmrc2018(spec):
simdata = {}
simdata["version"] = "v1.0-sim"
simdata["data"] = []
for ind in range(spec["data_size"]):
item = {}
para = {}
item["id"] = f"DEV_{ind}"
item["title"] = _GBK2312(spec["title_length"])
item["paragraphs"] = []
para["id"] = item["id"]
para["context"] = _GBK2312(spec["context_length"])
para["qas"] = []
for qind in range(spec["qas_size"]):
q = {}
q["question"] = _GBK2312(spec["query_length"])
q["id"] = f"{item['id']}_QUERY_{qind}"
q["answers"] = []
for ans in range(spec["answers_size"]):
ans = {}
ans["text"] = _GBK2312(spec["answers_length"])
ans["answer_start"] = 0
q["answers"].append(ans)
para["qas"].append(q)
item["paragraphs"].append(para)
simdata["data"].append(item)
return simdata
def _create_dir_if_nonexist(dirpath):
pathlib.Path(dirpath).mkdir(parents=True, exist_ok=True)
def _dump_data(data, path):
with open(path, "w", encoding='utf8') as dp:
json.dump(data, dp, indent=4, ensure_ascii=False)
def _generate_dev(batch_size):
CMRC2018_DEV_SPEC["data_size"] = batch_size * EVAL_NUM_BATCH
dev_data = _generate_cmrc2018(CMRC2018_DEV_SPEC)
_dump_data(dev_data, CMRC2018_DEV_SIM)
def _generate_train(batch_size):
CMRC2018_TRAIN_SPEC["data_size"] = batch_size * TRAIN_NUM_BATCH
dev_data = _generate_cmrc2018(CMRC2018_TRAIN_SPEC)
_dump_data(dev_data, CMRC2018_TRAIN_SIM)
# MUST be called after generate_dev() AND generate_train()!
def _generate_vocab():
never_split = ["[UNK]", "[SEP]", "[PAD]", "[CLS]", "[MASK]"]
VOCAB_SET.update(never_split)
with open(CMRC2018_VOCAB_SIM, "w") as vf:
vf.write("\n".join(list(VOCAB_SET)))
def _copy_bert_config():
current_dir = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(current_dir, "bert_config.json"), "r") as configf:
config = configf.read()
with open(CMRC2018_BERT_CONFIG, "w") as configf:
configf.write(config)
def _setup_os_env():
os.environ["TORCHBENCH_FASTNLP_CONFIG_PATH"] = CMRC2018_BERT_CONFIG
def _create_empty_bin():
CMRC2018_CONFIG_DIR = os.path.join(CMRC2018_DIR, "config")
bin_file = os.path.join(CMRC2018_CONFIG_DIR, "chinese_wwm_pytorch.bin")
with open(bin_file, "w") as bf:
bf.write("")
def generate_inputs(train_batch_size, eval_batch_size):
_create_dir_if_nonexist(CMRC2018_DIR)
_create_dir_if_nonexist(os.path.join(CMRC2018_DIR, "config"))
_generate_dev(eval_batch_size)
_generate_train(train_batch_size)
_generate_vocab()
_create_empty_bin()
_copy_bert_config()
_setup_os_env()
|
import torch
from . import eos_pytorch
from torchbenchmark.tasks import OTHER
from ...util.model import BenchmarkModel
from typing import Tuple
def _generate_inputs(size):
import math
import numpy as np
np.random.seed(17)
shape = (
math.ceil(2 * size ** (1/3)),
math.ceil(2 * size ** (1/3)),
math.ceil(0.25 * size ** (1/3)),
)
s = np.random.uniform(1e-2, 10, size=shape)
t = np.random.uniform(-12, 20, size=shape)
p = np.random.uniform(0, 1000, size=(1, 1, shape[-1]))
return s, t, p
class EquationOfState(torch.nn.Module):
def __init__(self):
super(EquationOfState, self).__init__()
def forward(self, s, t, p):
return eos_pytorch.gsw_dHdT(s, t, p)
class Model(BenchmarkModel):
task = OTHER.OTHER_TASKS
# Original size: [2 ** i for i in range(12, 23, 2)
# Source: https://github.com/dionhaefner/pyhpc-benchmarks/blob/650ecc650e394df829944ffcf09e9d646ec69691/run.py#L25
# Pick data point: i = 20, size = 1048576
DEFAULT_EVAL_BSIZE = 1048576
CANNOT_SET_CUSTOM_OPTIMIZER = True
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = EquationOfState().to(device=self.device)
input_size = self.batch_size
raw_inputs = _generate_inputs(input_size)
if hasattr(eos_pytorch, "prepare_inputs"):
inputs = eos_pytorch.prepare_inputs(*raw_inputs, device=device)
self.example_inputs = inputs
def get_module(self):
return self.model, self.example_inputs
def train(self):
raise NotImplementedError("Training not supported")
def eval(self) -> Tuple[torch.Tensor]:
model, example_inputs = self.get_module()
with torch.no_grad():
out = model(*example_inputs)
return (out, )
|
"""
==========================================================================
in-situ density, dynamic enthalpy and derivatives
from Absolute Salinity and Conservative
Temperature, using the computationally-efficient 48-term expression for
density in terms of SA, CT and p (IOC et al., 2010).
==========================================================================
"""
import torch
def gsw_dHdT(sa, ct, p):
"""
d/dT of dynamic enthalpy, analytical derivative
sa : Absolute Salinity [g/kg]
ct : Conservative Temperature [deg C]
p : sea pressure [dbar]
"""
v01 = 9.998420897506056e2
v02 = 2.839940833161907e0
v03 = -3.147759265588511e-2
v04 = 1.181805545074306e-3
v05 = -6.698001071123802e0
v06 = -2.986498947203215e-2
v07 = 2.327859407479162e-4
v08 = -3.988822378968490e-2
v09 = 5.095422573880500e-4
v10 = -1.426984671633621e-5
v11 = 1.645039373682922e-7
v12 = -2.233269627352527e-2
v13 = -3.436090079851880e-4
v14 = 3.726050720345733e-6
v15 = -1.806789763745328e-4
v16 = 6.876837219536232e-7
v17 = -3.087032500374211e-7
v18 = -1.988366587925593e-8
v19 = -1.061519070296458e-11
v20 = 1.550932729220080e-10
v21 = 1.0e0
v22 = 2.775927747785646e-3
v23 = -2.349607444135925e-5
v24 = 1.119513357486743e-6
v25 = 6.743689325042773e-10
v26 = -7.521448093615448e-3
v27 = -2.764306979894411e-5
v28 = 1.262937315098546e-7
v29 = 9.527875081696435e-10
v30 = -1.811147201949891e-11
v31 = -3.303308871386421e-5
v32 = 3.801564588876298e-7
v33 = -7.672876869259043e-9
v34 = -4.634182341116144e-11
v35 = 2.681097235569143e-12
v36 = 5.419326551148740e-6
v37 = -2.742185394906099e-5
v38 = -3.212746477974189e-7
v39 = 3.191413910561627e-9
v40 = -1.931012931541776e-12
v41 = -1.105097577149576e-7
v42 = 6.211426728363857e-10
v43 = -1.119011592875110e-10
v44 = -1.941660213148725e-11
v45 = -1.864826425365600e-14
v46 = 1.119522344879478e-14
v47 = -1.200507748551599e-15
v48 = 6.057902487546866e-17
t1 = v45 * ct
t2 = 0.2e1 * t1
t3 = v46 * sa
t4 = 0.5 * v12
t5 = v14 * ct
t7 = ct * (v13 + t5)
t8 = 0.5 * t7
t11 = sa * (v15 + v16 * ct)
t12 = 0.5 * t11
t13 = t4 + t8 + t12
t15 = v19 * ct
t19 = v17 + ct * (v18 + t15) + v20 * sa
t20 = 1.0 / t19
t24 = v47 + v48 * ct
t25 = 0.5 * v13
t26 = 1.0 * t5
t27 = sa * v16
t28 = 0.5 * t27
t29 = t25 + t26 + t28
t33 = t24 * t13
t34 = t19 ** 2
t35 = 1.0 / t34
t37 = v18 + 2.0 * t15
t38 = t35 * t37
t48 = ct * (v44 + t1 + t3)
t57 = v40 * ct
t59 = ct * (v39 + t57)
t64 = t13 ** 2
t68 = t20 * t29
t71 = t24 * t64
t74 = v04 * ct
t76 = ct * (v03 + t74)
t79 = v07 * ct
t82 = torch.sqrt(sa)
t83 = v11 * ct
t85 = ct * (v10 + t83)
t92 = (
v01
+ ct * (v02 + t76)
+ sa * (v05 + ct * (v06 + t79) + t82 * (v08 + ct * (v09 + t85)))
)
t93 = v48 * t92
t105 = (
v02
+ t76
+ ct * (v03 + 2.0 * t74)
+ sa * (v06 + 2.0 * t79 + t82 * (v09 + t85 + ct * (v10 + 2.0 * t83)))
)
t106 = t24 * t105
t107 = v44 + t2 + t3
t110 = v43 + t48
t117 = t24 * t92
t120 = 4.0 * t71 * t20 - t117 - 2.0 * t110 * t13
t123 = (
v38
+ t59
+ ct * (v39 + 2.0 * t57)
+ sa * v42
+ (
4.0 * v48 * t64 * t20
+ 8.0 * t33 * t68
- 4.0 * t71 * t38
- t93
- t106
- 2.0 * t107 * t13
- 2.0 * t110 * t29
)
* t20
- t120 * t35 * t37
)
t128 = t19 * p
t130 = p * (1.0 * v12 + 1.0 * t7 + 1.0 * t11 + t128)
t131 = 1.0 / t92
t133 = 1.0 + t130 * t131
t134 = torch.log(t133)
t143 = v37 + ct * (v38 + t59) + sa * (v41 + v42 * ct) + t120 * t20
t152 = t37 * p
t156 = t92 ** 2
t165 = v25 * ct
t167 = ct * (v24 + t165)
t169 = ct * (v23 + t167)
t175 = v30 * ct
t177 = ct * (v29 + t175)
t179 = ct * (v28 + t177)
t185 = v35 * ct
t187 = ct * (v34 + t185)
t189 = ct * (v33 + t187)
t199 = t13 * t20
t217 = 2.0 * t117 * t199 - t110 * t92
t234 = (
v21
+ ct * (v22 + t169)
+ sa * (v26 + ct * (v27 + t179) + v36 * sa + t82 * (v31 + ct * (v32 + t189)))
+ t217 * t20
)
t241 = t64 - t92 * t19
t242 = torch.sqrt(t241)
t243 = 1.0 / t242
t244 = t4 + t8 + t12 - t242
t245 = 1.0 / t244
t247 = t4 + t8 + t12 + t242 + t128
t248 = 1.0 / t247
t249 = t242 * t245 * t248
t252 = 1.0 + 2.0 * t128 * t249
t253 = torch.log(t252)
t254 = t243 * t253
t259 = t234 * t19 - t143 * t13
t264 = t259 * t20
t272 = 2.0 * t13 * t29 - t105 * t19 - t92 * t37
t282 = t128 * t242
t283 = t244 ** 2
t287 = t243 * t272 / 2.0
t292 = t247 ** 2
t305 = (
0.1e5
* p
* (
v44
+ t2
+ t3
- 2.0 * v48 * t13 * t20
- 2.0 * t24 * t29 * t20
+ 2.0 * t33 * t38
+ 0.5 * v48 * p
)
* t20
- 0.1e5 * p * (v43 + t48 - 2.0 * t33 * t20 + 0.5 * t24 * p) * t38
+ 0.5e4 * t123 * t20 * t134
- 0.5e4 * t143 * t35 * t134 * t37
+ 0.5e4
* t143
* t20
* (p * (1.0 * v13 + 2.0 * t5 + 1.0 * t27 + t152) * t131 - t130 / t156 * t105)
/ t133
+ 0.5e4
* (
(
v22
+ t169
+ ct * (v23 + t167 + ct * (v24 + 2.0 * t165))
+ sa
* (
v27
+ t179
+ ct * (v28 + t177 + ct * (v29 + 2.0 * t175))
+ t82 * (v32 + t189 + ct * (v33 + t187 + ct * (v34 + 2.0 * t185)))
)
+ (
2.0 * t93 * t199
+ 2.0 * t106 * t199
+ 2.0 * t117 * t68
- 2.0 * t117 * t13 * t35 * t37
- t107 * t92
- t110 * t105
)
* t20
- t217 * t35 * t37
)
* t19
+ t234 * t37
- t123 * t13
- t143 * t29
)
* t20
* t254
- 0.5e4 * t259 * t35 * t254 * t37
- 0.25e4 * t264 / t242 / t241 * t253 * t272
+ 0.5e4
* t264
* t243
* (
2.0 * t152 * t249
+ t128 * t243 * t245 * t248 * t272
- 2.0 * t282 / t283 * t248 * (t25 + t26 + t28 - t287)
- 2.0 * t282 * t245 / t292 * (t25 + t26 + t28 + t287 + t152)
)
/ t252
)
return t305
def prepare_inputs(sa, ct, p, device):
out = [
torch.as_tensor(a, device=device)
for a in (sa, ct, p)
]
if device == "gpu":
torch.cuda.synchronize()
return out
def run(sa, ct, p, device="cpu"):
with torch.no_grad():
out = gsw_dHdT(sa, ct, p)
if device == "gpu":
torch.cuda.synchronize()
return out
|
if __name__ == "__main__":
pass
|
# Generated by gen_torchvision_benchmark.py
import torch
import torch.optim as optim
import torchvision.models as models
from torch.quantization import quantize_fx
from torchbenchmark.tasks import COMPUTER_VISION
from ...util.model import BenchmarkModel
from typing import Tuple
class Model(BenchmarkModel):
task = COMPUTER_VISION.CLASSIFICATION
# Train batch size: 96
# Source: https://arxiv.org/pdf/1801.04381.pdf
DEFAULT_TRAIN_BSIZE = 96
DEFAULT_EVAL_BSIZE = 96
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
if test == "eval" and device != "cpu":
raise NotImplementedError("The eval test only supports CPU.")
if jit and test == "train":
raise NotImplementedError("torchscript operations should only be applied after quantization operations")
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.model = models.mobilenet_v2().to(self.device)
self.example_inputs = (torch.randn((self.batch_size, 3, 224, 224)).to(self.device),)
self.prep_qat_train() # config+prepare steps are required for both train and eval
if self.test == "eval":
self.prep_qat_eval()
self.optimizer = None
def prep_qat_train(self):
qconfig_dict = {"": torch.quantization.get_default_qat_qconfig('fbgemm')}
self.model.train()
self.model = quantize_fx.prepare_qat_fx(self.model, qconfig_dict, self.example_inputs)
def train(self):
if self.get_optimizer() is None:
self.set_optimizer(optim.Adam(self.model.parameters()))
loss = torch.nn.CrossEntropyLoss()
self.optimizer.zero_grad()
pred = self.model(*self.example_inputs)
y = torch.empty(pred.shape[0], dtype=torch.long, device=self.device).random_(pred.shape[1])
loss(pred, y).backward()
self.optimizer.step()
def prep_qat_eval(self):
self.model = quantize_fx.convert_fx(self.model)
self.model.eval()
def eval(self) -> Tuple[torch.Tensor]:
example_inputs = self.example_inputs[0][0].unsqueeze(0)
out = self.model(example_inputs)
return (out, )
def get_module(self):
return self.model, self.example_inputs
def get_optimizer(self):
return self.optimizer
def set_optimizer(self, optimizer) -> None:
self.optimizer = optimizer
|
import argparse
import numpy as np
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import optim
from typing import Tuple
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
from .pytorch_unet.unet import UNet
from .pytorch_unet.utils.dice_score import dice_loss
from ...util.model import BenchmarkModel
from torchbenchmark.tasks import COMPUTER_VISION
class Model(BenchmarkModel):
task = COMPUTER_VISION.SEGMENTATION
DEFAULT_TRAIN_BSIZE = 1
DEFAULT_EVAL_BSIZE = 1
DEFAULT_TRAIN_CUDA_PRECISION = "amp"
DEFAULT_EVAL_CUDA_PRECISION = "amp"
def __init__(self, test, device, batch_size=None, jit=False, extra_args=[]):
super().__init__(test=test, device=device, jit=jit, batch_size=batch_size, extra_args=extra_args)
self.args = self._get_args()
# The sample inputs shape used here mimic the setting of the original repo
# Source image link: https://www.kaggle.com/c/carvana-image-masking-challenge/code
# Source images are 1280 x 1918, but the original code scales it in half to 640 x 959
# The batch size is 1 and there are 3 channels for the image inputs and 1 for the mask
self.example_inputs = torch.rand((self.batch_size, 3, 640, 959), dtype=torch.float32).to(self.device)
self.model = UNet(n_channels=3, n_classes=2, bilinear=True).to(self.device)
if test == "train":
self.sample_masks = torch.randint(0, 1, (self.batch_size, 640, 959), dtype=torch.int64).to(self.device)
self.model.train()
elif test == "eval":
self.model.eval()
self.optimizer = optim.RMSprop(self.model.parameters(), lr=self.args.lr, weight_decay=1e-8, momentum=0.9)
def get_module(self):
return self.model, (self.example_inputs,)
def enable_amp(self):
self.args.amp = True
def train(self):
grad_scaler = torch.cuda.amp.GradScaler(enabled=self.args.amp)
criterion = nn.CrossEntropyLoss()
self.model.train()
if True:
with torch.cuda.amp.autocast(enabled=self.args.amp):
masks_pred = self.model(self.example_inputs)
masks_true = self.sample_masks
loss = criterion(masks_pred, masks_true) + \
dice_loss(
F.softmax(masks_pred, dim=1).float(),
F.one_hot(masks_true, self.model.n_classes).permute(0, 3, 1, 2).float(),
multiclass=True)
self.optimizer.zero_grad(set_to_none=True)
grad_scaler.scale(loss).backward()
grad_scaler.step(self.optimizer)
grad_scaler.update()
def jit_callback(self):
assert self.jit, "Calling JIT callback without specifying the JIT option."
if self.test == 'eval':
self.model = torch.jit.optimize_for_inference( \
torch.jit.freeze(torch.jit.script(self.model.eval()), preserved_attrs=["n_classes"]))
else:
self.model = torch.jit.script(self.model)
def eval(self) -> Tuple[torch.Tensor]:
self.model.eval()
with torch.no_grad():
with torch.cuda.amp.autocast(enabled=self.args.amp):
mask_pred = self.model(self.example_inputs)
if self.model.n_classes == 1:
mask_pred = (F.sigmoid(mask_pred) > 0.5).float()
else:
mask_pred = F.one_hot(mask_pred.argmax(dim=1), self.model.n_classes).permute(0, 3, 1, 2).float()
return (mask_pred, )
def _get_args(self):
parser = argparse.ArgumentParser(description='Train the UNet on images and target masks')
parser.add_argument('--learning-rate', '-l', metavar='LR', type=float, default=0.00001,
help='Learning rate', dest='lr')
parser.add_argument('--amp', action='store_true', default=False, help='Use mixed precision')
return parser.parse_args([])
|
import subprocess
import sys
def pip_install_requirements():
subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', '-r', 'pytorch_unet/requirements.txt'])
if __name__ == '__main__':
pip_install_requirements()
|
import argparse
import logging
import os
import numpy as np
import torch
import torch.nn.functional as F
from PIL import Image
from torchvision import transforms
from utils.data_loading import BasicDataset
from unet import UNet
from utils.utils import plot_img_and_mask
def predict_img(net,
full_img,
device,
scale_factor=1,
out_threshold=0.5):
net.eval()
img = torch.from_numpy(BasicDataset.preprocess(full_img, scale_factor, is_mask=False))
img = img.unsqueeze(0)
img = img.to(device=device, dtype=torch.float32)
with torch.no_grad():
output = net(img)
if net.n_classes > 1:
probs = F.softmax(output, dim=1)[0]
else:
probs = torch.sigmoid(output)[0]
tf = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((full_img.size[1], full_img.size[0])),
transforms.ToTensor()
])
full_mask = tf(probs.cpu()).squeeze()
if net.n_classes == 1:
return (full_mask > out_threshold).numpy()
else:
return F.one_hot(full_mask.argmax(dim=0), net.n_classes).permute(2, 0, 1).numpy()
def get_args():
parser = argparse.ArgumentParser(description='Predict masks from input images')
parser.add_argument('--model', '-m', default='MODEL.pth', metavar='FILE',
help='Specify the file in which the model is stored')
parser.add_argument('--input', '-i', metavar='INPUT', nargs='+', help='Filenames of input images', required=True)
parser.add_argument('--output', '-o', metavar='INPUT', nargs='+', help='Filenames of output images')
parser.add_argument('--viz', '-v', action='store_true',
help='Visualize the images as they are processed')
parser.add_argument('--no-save', '-n', action='store_true', help='Do not save the output masks')
parser.add_argument('--mask-threshold', '-t', type=float, default=0.5,
help='Minimum probability value to consider a mask pixel white')
parser.add_argument('--scale', '-s', type=float, default=0.5,
help='Scale factor for the input images')
return parser.parse_args()
def get_output_filenames(args):
def _generate_name(fn):
split = os.path.splitext(fn)
return f'{split[0]}_OUT{split[1]}'
return args.output or list(map(_generate_name, args.input))
def mask_to_image(mask: np.ndarray):
if mask.ndim == 2:
return Image.fromarray((mask * 255).astype(np.uint8))
elif mask.ndim == 3:
return Image.fromarray((np.argmax(mask, axis=0) * 255 / mask.shape[0]).astype(np.uint8))
if __name__ == '__main__':
args = get_args()
in_files = args.input
out_files = get_output_filenames(args)
net = UNet(n_channels=3, n_classes=2)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
logging.info(f'Loading model {args.model}')
logging.info(f'Using device {device}')
net.to(device=device)
net.load_state_dict(torch.load(args.model, map_location=device))
logging.info('Model loaded!')
for i, filename in enumerate(in_files):
logging.info(f'\nPredicting image {filename} ...')
img = Image.open(filename)
mask = predict_img(net=net,
full_img=img,
scale_factor=args.scale,
out_threshold=args.mask_threshold,
device=device)
if not args.no_save:
out_filename = out_files[i]
result = mask_to_image(mask)
result.save(out_filename)
logging.info(f'Mask saved to {out_filename}')
if args.viz:
logging.info(f'Visualizing results for image {filename}, close to continue...')
plot_img_and_mask(img, mask)
|
import argparse
import logging
import sys
from pathlib import Path
import torch
import torch.nn as nn
import torch.nn.functional as F
import wandb
from torch import optim
from torch.utils.data import DataLoader, random_split
from tqdm import tqdm
from utils.data_loading import BasicDataset, CarvanaDataset
from utils.dice_score import dice_loss
from evaluate import evaluate
from unet import UNet
dir_img = Path('./data/imgs/')
dir_mask = Path('./data/masks/')
dir_checkpoint = Path('./checkpoints/')
def train_net(net,
device,
epochs: int = 5,
batch_size: int = 1,
learning_rate: float = 0.001,
val_percent: float = 0.1,
save_checkpoint: bool = True,
img_scale: float = 0.5,
amp: bool = False):
# 1. Create dataset
try:
dataset = CarvanaDataset(dir_img, dir_mask, img_scale)
except (AssertionError, RuntimeError):
dataset = BasicDataset(dir_img, dir_mask, img_scale)
# 2. Split into train / validation partitions
n_val = int(len(dataset) * val_percent)
n_train = len(dataset) - n_val
train_set, val_set = random_split(dataset, [n_train, n_val], generator=torch.Generator().manual_seed(0))
# 3. Create data loaders
loader_args = dict(batch_size=batch_size, num_workers=4, pin_memory=True)
train_loader = DataLoader(train_set, shuffle=True, **loader_args)
val_loader = DataLoader(val_set, shuffle=False, drop_last=True, **loader_args)
# (Initialize logging)
experiment = wandb.init(project='U-Net', resume='allow', anonymous='must')
experiment.config.update(dict(epochs=epochs, batch_size=batch_size, learning_rate=learning_rate,
val_percent=val_percent, save_checkpoint=save_checkpoint, img_scale=img_scale,
amp=amp))
logging.info(f'''Starting training:
Epochs: {epochs}
Batch size: {batch_size}
Learning rate: {learning_rate}
Training size: {n_train}
Validation size: {n_val}
Checkpoints: {save_checkpoint}
Device: {device.type}
Images scaling: {img_scale}
Mixed Precision: {amp}
''')
# 4. Set up the optimizer, the loss, the learning rate scheduler and the loss scaling for AMP
optimizer = optim.RMSprop(net.parameters(), lr=learning_rate, weight_decay=1e-8, momentum=0.9)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=2) # goal: maximize Dice score
grad_scaler = torch.cuda.amp.GradScaler(enabled=amp)
criterion = nn.CrossEntropyLoss()
global_step = 0
# 5. Begin training
for epoch in range(epochs):
net.train()
epoch_loss = 0
with tqdm(total=n_train, desc=f'Epoch {epoch + 1}/{epochs}', unit='img') as pbar:
for batch in train_loader:
images = batch['image']
true_masks = batch['mask']
assert images.shape[1] == net.n_channels, \
f'Network has been defined with {net.n_channels} input channels, ' \
f'but loaded images have {images.shape[1]} channels. Please check that ' \
'the images are loaded correctly.'
images = images.to(device=device, dtype=torch.float32)
true_masks = true_masks.to(device=device, dtype=torch.long)
with torch.cuda.amp.autocast(enabled=amp):
masks_pred = net(images)
loss = criterion(masks_pred, true_masks) \
+ dice_loss(F.softmax(masks_pred, dim=1).float(),
F.one_hot(true_masks, net.n_classes).permute(0, 3, 1, 2).float(),
multiclass=True)
optimizer.zero_grad(set_to_none=True)
grad_scaler.scale(loss).backward()
grad_scaler.step(optimizer)
grad_scaler.update()
pbar.update(images.shape[0])
global_step += 1
epoch_loss += loss.item()
experiment.log({
'train loss': loss.item(),
'step': global_step,
'epoch': epoch
})
pbar.set_postfix(**{'loss (batch)': loss.item()})
# Evaluation round
if global_step % (n_train // (10 * batch_size)) == 0:
histograms = {}
for tag, value in net.named_parameters():
tag = tag.replace('/', '.')
histograms['Weights/' + tag] = wandb.Histogram(value.data.cpu())
histograms['Gradients/' + tag] = wandb.Histogram(value.grad.data.cpu())
val_score = evaluate(net, val_loader, device)
scheduler.step(val_score)
logging.info('Validation Dice score: {}'.format(val_score))
experiment.log({
'learning rate': optimizer.param_groups[0]['lr'],
'validation Dice': val_score,
'images': wandb.Image(images[0].cpu()),
'masks': {
'true': wandb.Image(true_masks[0].float().cpu()),
'pred': wandb.Image(torch.softmax(masks_pred, dim=1)[0].float().cpu()),
},
'step': global_step,
'epoch': epoch,
**histograms
})
if save_checkpoint:
Path(dir_checkpoint).mkdir(parents=True, exist_ok=True)
torch.save(net.state_dict(), str(dir_checkpoint / 'checkpoint_epoch{}.pth'.format(epoch + 1)))
logging.info(f'Checkpoint {epoch + 1} saved!')
def get_args():
parser = argparse.ArgumentParser(description='Train the UNet on images and target masks')
parser.add_argument('--epochs', '-e', metavar='E', type=int, default=5, help='Number of epochs')
parser.add_argument('--batch-size', '-b', dest='batch_size', metavar='B', type=int, default=1, help='Batch size')
parser.add_argument('--learning-rate', '-l', metavar='LR', type=float, default=0.00001,
help='Learning rate', dest='lr')
parser.add_argument('--load', '-f', type=str, default=False, help='Load model from a .pth file')
parser.add_argument('--scale', '-s', type=float, default=0.5, help='Downscaling factor of the images')
parser.add_argument('--validation', '-v', dest='val', type=float, default=10.0,
help='Percent of the data that is used as validation (0-100)')
parser.add_argument('--amp', action='store_true', default=False, help='Use mixed precision')
return parser.parse_args()
if __name__ == '__main__':
args = get_args()
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
logging.info(f'Using device {device}')
# Change here to adapt to your data
# n_channels=3 for RGB images
# n_classes is the number of probabilities you want to get per pixel
net = UNet(n_channels=3, n_classes=2, bilinear=True)
logging.info(f'Network:\n'
f'\t{net.n_channels} input channels\n'
f'\t{net.n_classes} output channels (classes)\n'
f'\t{"Bilinear" if net.bilinear else "Transposed conv"} upscaling')
if args.load:
net.load_state_dict(torch.load(args.load, map_location=device))
logging.info(f'Model loaded from {args.load}')
net.to(device=device)
try:
train_net(net=net,
epochs=args.epochs,
batch_size=args.batch_size,
learning_rate=args.lr,
device=device,
img_scale=args.scale,
val_percent=args.val / 100,
amp=args.amp)
except KeyboardInterrupt:
torch.save(net.state_dict(), 'INTERRUPTED.pth')
logging.info('Saved interrupt')
sys.exit(0)
|
import torch
import torch.nn.functional as F
from tqdm import tqdm
from utils.dice_score import multiclass_dice_coeff, dice_coeff
def evaluate(net, dataloader, device):
net.eval()
num_val_batches = len(dataloader)
dice_score = 0
# iterate over the validation set
for batch in tqdm(dataloader, total=num_val_batches, desc='Validation round', unit='batch', leave=False):
image, mask_true = batch['image'], batch['mask']
# move images and labels to correct device and type
image = image.to(device=device, dtype=torch.float32)
mask_true = mask_true.to(device=device, dtype=torch.long)
mask_true = F.one_hot(mask_true, net.n_classes).permute(0, 3, 1, 2).float()
with torch.no_grad():
# predict the mask
mask_pred = net(image)
# convert to one-hot format
if net.n_classes == 1:
mask_pred = (F.sigmoid(mask_pred) > 0.5).float()
# compute the Dice score
dice_score += dice_coeff(mask_pred, mask_true, reduce_batch_first=False)
else:
mask_pred = F.one_hot(mask_pred.argmax(dim=1), net.n_classes).permute(0, 3, 1, 2).float()
# compute the Dice score, ignoring background
dice_score += multiclass_dice_coeff(mask_pred[:, 1:, ...], mask_true[:, 1:, ...], reduce_batch_first=False)
net.train()
return dice_score / num_val_batches
|
import torch
from unet import UNet as _UNet
def unet_carvana(pretrained=False):
"""
UNet model trained on the Carvana dataset ( https://www.kaggle.com/c/carvana-image-masking-challenge/data ).
Set the scale to 0.5 (50%) when predicting.
"""
net = _UNet(n_channels=3, n_classes=2, bilinear=True)
if pretrained:
checkpoint = 'https://github.com/milesial/Pytorch-UNet/releases/download/v2.0/unet_carvana_scale0.5_epoch1.pth'
net.load_state_dict(torch.hub.load_state_dict_from_url(checkpoint, progress=True))
return net
|
import logging
from os import listdir
from os.path import splitext
from pathlib import Path
import numpy as np
import torch
from PIL import Image
from torch.utils.data import Dataset
class BasicDataset(Dataset):
def __init__(self, images_dir: str, masks_dir: str, scale: float = 1.0, mask_suffix: str = ''):
self.images_dir = Path(images_dir)
self.masks_dir = Path(masks_dir)
assert 0 < scale <= 1, 'Scale must be between 0 and 1'
self.scale = scale
self.mask_suffix = mask_suffix
self.ids = [splitext(file)[0] for file in listdir(images_dir) if not file.startswith('.')]
if not self.ids:
raise RuntimeError(f'No input file found in {images_dir}, make sure you put your images there')
logging.info(f'Creating dataset with {len(self.ids)} examples')
def __len__(self):
return len(self.ids)
@classmethod
def preprocess(cls, pil_img, scale, is_mask):
w, h = pil_img.size
newW, newH = int(scale * w), int(scale * h)
assert newW > 0 and newH > 0, 'Scale is too small, resized images would have no pixel'
pil_img = pil_img.resize((newW, newH))
img_ndarray = np.asarray(pil_img)
if img_ndarray.ndim == 2 and not is_mask:
img_ndarray = img_ndarray[np.newaxis, ...]
elif not is_mask:
img_ndarray = img_ndarray.transpose((2, 0, 1))
if not is_mask:
img_ndarray = img_ndarray / 255
return img_ndarray
@classmethod
def load(cls, filename):
ext = splitext(filename)[1]
if ext in ['.npz', '.npy']:
return Image.fromarray(np.load(filename))
elif ext in ['.pt', '.pth']:
return Image.fromarray(torch.load(filename).numpy())
else:
return Image.open(filename)
def __getitem__(self, idx):
name = self.ids[idx]
mask_file = list(self.masks_dir.glob(name + self.mask_suffix + '.*'))
img_file = list(self.images_dir.glob(name + '.*'))
assert len(mask_file) == 1, f'Either no mask or multiple masks found for the ID {name}: {mask_file}'
assert len(img_file) == 1, f'Either no image or multiple images found for the ID {name}: {img_file}'
mask = self.load(mask_file[0])
img = self.load(img_file[0])
assert img.size == mask.size, \
'Image and mask {name} should be the same size, but are {img.size} and {mask.size}'
img = self.preprocess(img, self.scale, is_mask=False)
mask = self.preprocess(mask, self.scale, is_mask=True)
return {
'image': torch.as_tensor(img.copy()).float().contiguous(),
'mask': torch.as_tensor(mask.copy()).long().contiguous()
}
class CarvanaDataset(BasicDataset):
def __init__(self, images_dir, masks_dir, scale=1):
super().__init__(images_dir, masks_dir, scale, mask_suffix='_mask')
|
import torch
from torch import Tensor
def dice_coeff(input: Tensor, target: Tensor, reduce_batch_first: bool = False, epsilon=1e-6):
# Average of Dice coefficient for all batches, or for a single mask
assert input.size() == target.size()
if input.dim() == 2 and reduce_batch_first:
raise ValueError(f'Dice: asked to reduce batch but got tensor without batch dimension (shape {input.shape})')
if input.dim() == 2 or reduce_batch_first:
inter = torch.dot(input.reshape(-1), target.reshape(-1))
sets_sum = torch.sum(input) + torch.sum(target)
if sets_sum.item() == 0:
sets_sum = 2 * inter
return (2 * inter + epsilon) / (sets_sum + epsilon)
else:
# compute and average metric for each batch element
dice = 0
for i in range(input.shape[0]):
dice += dice_coeff(input[i, ...], target[i, ...])
return dice / input.shape[0]
def multiclass_dice_coeff(input: Tensor, target: Tensor, reduce_batch_first: bool = False, epsilon=1e-6):
# Average of Dice coefficient for all classes
assert input.size() == target.size()
dice = 0
for channel in range(input.shape[1]):
dice += dice_coeff(input[:, channel, ...], target[:, channel, ...], reduce_batch_first, epsilon)
return dice / input.shape[1]
def dice_loss(input: Tensor, target: Tensor, multiclass: bool = False):
# Dice loss (objective to minimize) between 0 and 1
assert input.size() == target.size()
fn = multiclass_dice_coeff if multiclass else dice_coeff
return 1 - fn(input, target, reduce_batch_first=True)
|
import matplotlib.pyplot as plt
def plot_img_and_mask(img, mask):
classes = mask.shape[0] if len(mask.shape) > 2 else 1
fig, ax = plt.subplots(1, classes + 1)
ax[0].set_title('Input image')
ax[0].imshow(img)
if classes > 1:
for i in range(classes):
ax[i + 1].set_title(f'Output mask (class {i + 1})')
ax[i + 1].imshow(mask[:, :, i])
else:
ax[1].set_title(f'Output mask')
ax[1].imshow(mask)
plt.xticks([]), plt.yticks([])
plt.show()
|
from .unet_model import UNet
|
""" Parts of the U-Net model """
import torch
import torch.nn as nn
import torch.nn.functional as F
class DoubleConv(nn.Module):
"""(convolution => [BN] => ReLU) * 2"""
def __init__(self, in_channels, out_channels, mid_channels=None):
super().__init__()
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(mid_channels),
nn.ReLU(inplace=True),
nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
return self.double_conv(x)
class Down(nn.Module):
"""Downscaling with maxpool then double conv"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
DoubleConv(in_channels, out_channels)
)
def forward(self, x):
return self.maxpool_conv(x)
class Up(nn.Module):
"""Upscaling then double conv"""
def __init__(self, in_channels, out_channels, bilinear=True):
super().__init__()
# if bilinear, use the normal convolutions to reduce the number of channels
if bilinear:
self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
else:
self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
self.conv = DoubleConv(in_channels, out_channels)
def forward(self, x1, x2):
x1 = self.up(x1)
# input is CHW
diffY = x2.size()[2] - x1.size()[2]
diffX = x2.size()[3] - x1.size()[3]
x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
diffY // 2, diffY - diffY // 2])
# if you have padding issues, see
# https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
# https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
x = torch.cat([x2, x1], dim=1)
return self.conv(x)
class OutConv(nn.Module):
def __init__(self, in_channels, out_channels):
super(OutConv, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
def forward(self, x):
return self.conv(x)
|
""" Full assembly of the parts to form the complete network """
from .unet_parts import *
class UNet(nn.Module):
def __init__(self, n_channels, n_classes, bilinear=True):
super(UNet, self).__init__()
self.n_channels = n_channels
self.n_classes = n_classes
self.bilinear = bilinear
self.inc = DoubleConv(n_channels, 64)
self.down1 = Down(64, 128)
self.down2 = Down(128, 256)
self.down3 = Down(256, 512)
factor = 2 if bilinear else 1
self.down4 = Down(512, 1024 // factor)
self.up1 = Up(1024, 512 // factor, bilinear)
self.up2 = Up(512, 256 // factor, bilinear)
self.up3 = Up(256, 128 // factor, bilinear)
self.up4 = Up(128, 64, bilinear)
self.outc = OutConv(64, n_classes)
def forward(self, x):
x1 = self.inc(x)
x2 = self.down1(x1)
x3 = self.down2(x2)
x4 = self.down3(x3)
x5 = self.down4(x4)
x = self.up1(x5, x4)
x = self.up2(x, x3)
x = self.up3(x, x2)
x = self.up4(x, x1)
logits = self.outc(x)
return logits
|
from torchbenchmark.util.framework.vision.model_factory import TorchVisionModel
from torchbenchmark.tasks import COMPUTER_VISION
import torchvision.models as models
class Model(TorchVisionModel):
task = COMPUTER_VISION.CLASSIFICATION
DEFAULT_TRAIN_BSIZE = 32
DEFAULT_EVAL_BSIZE = 32
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(model_name="resnet152", test=test, device=device, jit=jit,
batch_size=batch_size, weights=models.ResNet152_Weights.IMAGENET1K_V1,
extra_args=extra_args)
|
from torchbenchmark.util.framework.vision.model_factory import TorchVisionModel
from torchbenchmark.tasks import COMPUTER_VISION
import torchvision.models as models
class Model(TorchVisionModel):
task = COMPUTER_VISION.CLASSIFICATION
DEFAULT_TRAIN_BSIZE = 16
DEFAULT_EVAL_BSIZE = 8
def __init__(self, test, device, jit=False, batch_size=None, extra_args=[]):
super().__init__(model_name="resnet18", test=test, device=device, jit=jit,
batch_size=batch_size, weights=models.ResNet18_Weights.IMAGENET1K_V1,
extra_args=extra_args)
|
import numpy as np
import torch
import torchvision
import cv2, pdb
def composite4(fg, bg, a):
fg = np.array(fg, np.float32)
alpha= np.expand_dims(a / 255,axis=2)
im = alpha * fg + (1 - alpha) * bg
im = im.astype(np.uint8)
return im
def compose_image_withshift(alpha_pred,fg_pred,bg,seg):
image_sh=torch.zeros(fg_pred.shape)
if alpha_pred.is_cuda:
image_sh = image_sh.cuda()
for t in range(0,fg_pred.shape[0]):
al_tmp=to_image(seg[t,...]).squeeze(2)
where = np.array(np.where((al_tmp>0.1).astype(np.float32)))
x1, y1 = np.amin(where, axis=1)
x2, y2 = np.amax(where, axis=1)
#select shift
n=np.random.randint(-(y1-10),al_tmp.shape[1]-y2-10)
#n positive indicates shift to right
alpha_pred_sh=torch.cat((alpha_pred[t,:,:,-n:],alpha_pred[t,:,:,:-n]),dim=2)
fg_pred_sh=torch.cat((fg_pred[t,:,:,-n:],fg_pred[t,:,:,:-n]),dim=2)
alpha_pred_sh=(alpha_pred_sh+1)/2
image_sh[t,...]=fg_pred_sh*alpha_pred_sh + (1-alpha_pred_sh)*bg[t,...]
if alpha_pred.is_cuda:
image_sh = image_sh.cuda()
return torch.autograd.Variable(image_sh)
def get_bbox(mask,R,C):
where = np.array(np.where(mask))
x1, y1 = np.amin(where, axis=1)
x2, y2 = np.amax(where, axis=1)
bbox_init=[x1,y1,np.maximum(x2-x1,y2-y1),np.maximum(x2-x1,y2-y1)]
bbox=create_bbox(bbox_init,(R,C))
return bbox
def crop_images(crop_list,reso,bbox):
for i in range(0,len(crop_list)):
img=crop_list[i]
if img.ndim>=3:
img_crop=img[bbox[0]:bbox[0]+bbox[2],bbox[1]:bbox[1]+bbox[3],...]; img_crop=cv2.resize(img_crop,reso)
else:
img_crop=img[bbox[0]:bbox[0]+bbox[2],bbox[1]:bbox[1]+bbox[3]]; img_crop=cv2.resize(img_crop,reso)
crop_list[i]=img_crop
return crop_list
def create_bbox(bbox_init,sh):
w=np.maximum(bbox_init[2],bbox_init[3])
x1=bbox_init[0]-0.1*w
y1=bbox_init[1]-0.1*w
x2=bbox_init[0]+1.1*w
y2=bbox_init[1]+1.1*w
if x1<0: x1=0
if y1<0: y1=0
if x2>=sh[0]: x2=sh[0]-1
if y2>=sh[1]: y2=sh[1]-1
bbox=np.around([x1,y1,x2-x1,y2-y1]).astype('int')
return bbox
def uncrop(alpha,bbox,R=720,C=1280):
alpha=cv2.resize(alpha,(bbox[3],bbox[2]))
if alpha.ndim==2:
alpha_uncrop=np.zeros((R,C))
alpha_uncrop[bbox[0]:bbox[0]+bbox[2],bbox[1]:bbox[1]+bbox[3]]=alpha
else:
alpha_uncrop=np.zeros((R,C,3))
alpha_uncrop[bbox[0]:bbox[0]+bbox[2],bbox[1]:bbox[1]+bbox[3],:]=alpha
return alpha_uncrop.astype(np.uint8)
def to_image(rec0):
rec0=((rec0.data).cpu()).numpy()
rec0=(rec0+1)/2
rec0=rec0.transpose((1,2,0))
rec0[rec0>1]=1
rec0[rec0<0]=0
return rec0
def write_tb_log(image,tag,log_writer,i):
# image1
output_to_show = image.cpu().data[0:4,...]
output_to_show = (output_to_show + 1)/2.0
grid = torchvision.utils.make_grid(output_to_show,nrow=4)
log_writer.add_image(tag, grid, i + 1)
|
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
#import matplotlib.pyplot as plt
import pdb
from torch.nn.modules.loss import _Loss
from torch.autograd import Function, Variable
#import scipy.io as sio
class alpha_loss(_Loss):
def __init__(self):
super(alpha_loss,self).__init__()
def forward(self,alpha,alpha_pred,mask):
return normalized_l1_loss(alpha,alpha_pred,mask)
class compose_loss(_Loss):
def __init__(self):
super(compose_loss,self).__init__()
def forward(self,image,alpha_pred,fg,bg,mask):
alpha_pred=(alpha_pred+1)/2
comp=fg*alpha_pred + (1-alpha_pred)*bg
return normalized_l1_loss(image,comp,mask)
class alpha_gradient_loss(_Loss):
def __init__(self):
super(alpha_gradient_loss,self).__init__()
def forward(self,alpha,alpha_pred,mask):
if alpha.is_cuda:
fx = torch.Tensor([[1, 0, -1],[2, 0, -2],[1, 0, -1]]); fx=fx.view((1,1,3,3)); fx=Variable(fx.cuda())
fy = torch.Tensor([[1, 2, 1],[0, 0, 0],[-1, -2, -1]]); fy=fy.view((1,1,3,3)); fy=Variable(fy.cuda())
else:
fx = torch.Tensor([[1, 0, -1],[2, 0, -2],[1, 0, -1]]); fx=fx.view((1,1,3,3)); fx=Variable(fx)
fy = torch.Tensor([[1, 2, 1],[0, 0, 0],[-1, -2, -1]]); fy=fy.view((1,1,3,3)); fy=Variable(fy)
G_x = F.conv2d(alpha,fx,padding=1); G_y = F.conv2d(alpha,fy,padding=1)
G_x_pred = F.conv2d(alpha_pred,fx,padding=1); G_y_pred = F.conv2d(alpha_pred,fy,padding=1)
loss=normalized_l1_loss(G_x,G_x_pred,mask) + normalized_l1_loss(G_y,G_y_pred,mask)
return loss
class alpha_gradient_reg_loss(_Loss):
def __init__(self):
super(alpha_gradient_reg_loss,self).__init__()
def forward(self,alpha,mask):
if alpha.is_cuda:
fx = torch.Tensor([[1, 0, -1],[2, 0, -2],[1, 0, -1]]); fx=fx.view((1,1,3,3)); fx=Variable(fx.cuda())
fy = torch.Tensor([[1, 2, 1],[0, 0, 0],[-1, -2, -1]]); fy=fy.view((1,1,3,3)); fy=Variable(fy.cuda())
else:
fx = torch.Tensor([[1, 0, -1],[2, 0, -2],[1, 0, -1]]); fx=fx.view((1,1,3,3)); fx=Variable(fx)
fy = torch.Tensor([[1, 2, 1],[0, 0, 0],[-1, -2, -1]]); fy=fy.view((1,1,3,3)); fy=Variable(fy)
G_x = F.conv2d(alpha,fx,padding=1); G_y = F.conv2d(alpha,fy,padding=1)
loss=(torch.sum(torch.abs(G_x))+torch.sum(torch.abs(G_y)))/torch.sum(mask)
return loss
class GANloss(_Loss):
def __init__(self):
super(GANloss,self).__init__()
def forward(self,pred,label_type):
MSE=nn.MSELoss()
loss=0
for i in range(0,len(pred)):
if label_type:
labels=torch.ones(pred[i][0].shape)
else:
labels=torch.zeros(pred[i][0].shape)
if pred[i][0].is_cuda:
labels=Variable(labels.cuda())
else:
labels=Variable(labels)
loss += MSE(pred[i][0],labels)
return loss/len(pred)
def normalized_l1_loss(alpha,alpha_pred,mask):
loss=0; eps=1e-6;
for i in range(alpha.shape[0]):
if mask[i,...].sum()>0:
loss = loss + torch.sum(torch.abs(alpha[i,...]*mask[i,...]-alpha_pred[i,...]*mask[i,...]))/(torch.sum(mask[i,...])+eps)
loss=loss/alpha.shape[0]
return loss |
import os
from io import BytesIO
import tarfile
import tempfile
from six.moves import urllib
import numpy as np
from PIL import Image
import cv2, pdb, glob, argparse
import tensorflow as tf
class DeepLabModel(object):
"""Class to load deeplab model and run inference."""
INPUT_TENSOR_NAME = 'ImageTensor:0'
OUTPUT_TENSOR_NAME = 'SemanticPredictions:0'
INPUT_SIZE = 513
FROZEN_GRAPH_NAME = 'frozen_inference_graph'
def __init__(self, tarball_path):
#"""Creates and loads pretrained deeplab model."""
self.graph = tf.Graph()
graph_def = None
# Extract frozen graph from tar archive.
tar_file = tarfile.open(tarball_path)
for tar_info in tar_file.getmembers():
if self.FROZEN_GRAPH_NAME in os.path.basename(tar_info.name):
file_handle = tar_file.extractfile(tar_info)
graph_def = tf.GraphDef.FromString(file_handle.read())
break
tar_file.close()
if graph_def is None:
raise RuntimeError('Cannot find inference graph in tar archive.')
with self.graph.as_default():
tf.import_graph_def(graph_def, name='')
self.sess = tf.Session(graph=self.graph)
def run(self, image):
"""Runs inference on a single image.
Args:
image: A PIL.Image object, raw input image.
Returns:
resized_image: RGB image resized from original input image.
seg_map: Segmentation map of `resized_image`.
"""
width, height = image.size
resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)
target_size = (int(resize_ratio * width), int(resize_ratio * height))
resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)
batch_seg_map = self.sess.run(
self.OUTPUT_TENSOR_NAME,
feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})
seg_map = batch_seg_map[0]
return resized_image, seg_map
def create_pascal_label_colormap():
"""Creates a label colormap used in PASCAL VOC segmentation benchmark.
Returns:
A Colormap for visualizing segmentation results.
"""
colormap = np.zeros((256, 3), dtype=int)
ind = np.arange(256, dtype=int)
for shift in reversed(range(8)):
for channel in range(3):
colormap[:, channel] |= ((ind >> channel) & 1) << shift
ind >>= 3
return colormap
def label_to_color_image(label):
"""Adds color defined by the dataset colormap to the label.
Args:
label: A 2D array with integer type, storing the segmentation label.
Returns:
result: A 2D array with floating type. The element of the array
is the color indexed by the corresponding element in the input label
to the PASCAL color map.
Raises:
ValueError: If label is not of rank 2 or its value is larger than color
map maximum entry.
"""
if label.ndim != 2:
raise ValueError('Expect 2-D input label')
colormap = create_pascal_label_colormap()
if np.max(label) >= len(colormap):
raise ValueError('label value too large.')
return colormap[label]
parser = argparse.ArgumentParser(description='Deeplab Segmentation')
parser.add_argument('-i', '--input_dir', type=str, required=True,help='Directory to save the output results. (required)')
args=parser.parse_args()
dir_name=args.input_dir;
## setup ####################
LABEL_NAMES = np.asarray([
'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tv'
])
FULL_LABEL_MAP = np.arange(len(LABEL_NAMES)).reshape(len(LABEL_NAMES), 1)
FULL_COLOR_MAP = label_to_color_image(FULL_LABEL_MAP)
MODEL_NAME = 'xception_coco_voctrainval' # @param ['mobilenetv2_coco_voctrainaug', 'mobilenetv2_coco_voctrainval', 'xception_coco_voctrainaug', 'xception_coco_voctrainval']
_DOWNLOAD_URL_PREFIX = 'http://download.tensorflow.org/models/'
_MODEL_URLS = {
'mobilenetv2_coco_voctrainaug':
'deeplabv3_mnv2_pascal_train_aug_2018_01_29.tar.gz',
'mobilenetv2_coco_voctrainval':
'deeplabv3_mnv2_pascal_trainval_2018_01_29.tar.gz',
'xception_coco_voctrainaug':
'deeplabv3_pascal_train_aug_2018_01_04.tar.gz',
'xception_coco_voctrainval':
'deeplabv3_pascal_trainval_2018_01_04.tar.gz',
}
_TARBALL_NAME = _MODEL_URLS[MODEL_NAME]
model_dir = 'deeplab_model'
if not os.path.exists(model_dir):
tf.gfile.MakeDirs(model_dir)
download_path = os.path.join(model_dir, _TARBALL_NAME)
if not os.path.exists(download_path):
print('downloading model to %s, this might take a while...' % download_path)
urllib.request.urlretrieve(_DOWNLOAD_URL_PREFIX + _MODEL_URLS[MODEL_NAME],
download_path)
print('download completed! loading DeepLab model...')
MODEL = DeepLabModel(download_path)
print('model loaded successfully!')
#######################################################################################
list_im=glob.glob(dir_name + '/*_img.png'); list_im.sort()
for i in range(0,len(list_im)):
image = Image.open(list_im[i])
res_im,seg=MODEL.run(image)
seg=cv2.resize(seg.astype(np.uint8),image.size)
mask_sel=(seg==15).astype(np.float32)
name=list_im[i].replace('img','masksDL')
cv2.imwrite(name,(255*mask_sel).astype(np.uint8))
str_msg='\nDone: ' + dir_name
print(str_msg)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.