def encode(argv):
parser = argparse.ArgumentParser(description='Encode image to bit-stream')
parser.add_argument('image', type=str)
parser.add_argument('--model',
choices=models.keys(),
default=list(models.keys())[0],
help='NN model to use (default: %(default)s)')
parser.add_argument('-m',
'--metric',
choices=['mse'],
default='mse',
help='metric trained against (default: %(default)s')
parser.add_argument('-q',
'--quality',
choices=list(range(1, 9)),
type=int,
default=3,
help='Quality setting (default: %(default)s)')
parser.add_argument('-c',
'--coder',
choices=compressai.available_entropy_coders(),
default=compressai.available_entropy_coders()[0],
help='Entropy coder (default: %(default)s)')
parser.add_argument('-o', '--output', help='Output path')
args = parser.parse_args(argv)
if not args.output:
args.output = Path(Path(args.image).resolve().name).with_suffix('.bin')
_encode(args.image, args.model, args.metric, args.quality, args.coder,
args.output)
def setup_args():
parser = argparse.ArgumentParser(description='Run model on image dataset')
parser.add_argument('model',
type=str,
choices=models.keys(),
help='model architecture')
parser.add_argument('-m',
'--metric',
type=str,
choices=['mse'],
default='mse',
help='metric trained against (default: %(default)s)')
parser.add_argument('dataset', type=str, help='dataset path')
parser.add_argument('-c',
'--entropy-coder',
choices=compressai.available_entropy_coders(),
default=compressai.available_entropy_coders()[0],
help='Entropy coder (default: %(default)s)')
parser.add_argument('-q',
'--quality',
dest='qualities',
nargs='+',
type=int,
default=range(1, 9))
parser.add_argument(
'--entropy-estimation',
action='store_true',
help='Use evaluated entropy estimation (no entropy coding)')
return parser
def encode(argv):
parser = argparse.ArgumentParser(description="Encode image to bit-stream")
parser.add_argument("image", type=str)
parser.add_argument(
"--model",
choices=models.keys(),
default=list(models.keys())[0],
help="NN model to use (default: %(default)s)",
)
parser.add_argument(
"-m",
"--metric",
choices=["mse"],
default="mse",
help="metric trained against (default: %(default)s",
)
parser.add_argument(
"-q",
"--quality",
choices=list(range(1, 9)),
type=int,
default=3,
help="Quality setting (default: %(default)s)",
)
parser.add_argument(
"-c",
"--coder",
choices=compressai.available_entropy_coders(),
default=compressai.available_entropy_coders()[0],
help="Entropy coder (default: %(default)s)",
)
parser.add_argument("-o", "--output", help="Output path")
args = parser.parse_args(argv)
if not args.output:
args.output = Path(Path(args.image).resolve().name).with_suffix(".bin")
_encode(args.image, args.model, args.metric, args.quality, args.coder,
args.output)
def parse_args(argv):
parser = argparse.ArgumentParser(description="Example training script.")
parser.add_argument(
"-m",
"--model",
default="bmshj2018-factorized",
choices=models.keys(),
help="Model architecture (default: %(default)s)",
)
parser.add_argument(
"-d", "--dataset", type=str, required=True, help="Training dataset"
)
parser.add_argument(
"-e",
"--epochs",
default=100,
type=int,
help="Number of epochs (default: %(default)s)",
)
parser.add_argument(
"-lr",
"--learning-rate",
default=1e-4,
type=float,
help="Learning rate (default: %(default)s)",
)
parser.add_argument(
"-n",
"--num-workers",
type=int,
default=30,
help="Dataloaders threads (default: %(default)s)",
)
parser.add_argument(
"--lambda",
dest="lmbda",
type=float,
default=1e-2,
help="Bit-rate distortion parameter (default: %(default)s)",
)
parser.add_argument(
"--batch-size", type=int, default=16, help="Batch size (default: %(default)s)"
)
parser.add_argument(
"--test-batch-size",
type=int,
default=64,
help="Test batch size (default: %(default)s)",
)
parser.add_argument(
"--aux-learning-rate",
default=1e-3,
help="Auxiliary loss learning rate (default: %(default)s)",
)
parser.add_argument(
"--patch-size",
type=int,
nargs=2,
default=(256, 256),
help="Size of the patches to be cropped (default: %(default)s)",
)
parser.add_argument("--cuda", action="store_true", help="Use cuda")
parser.add_argument("--save", action="store_true", help="Save model to disk")
parser.add_argument(
"--seed", type=float, help="Set random seed for reproducibility"
)
parser.add_argument(
"--clip_max_norm",
default=1.0,
type=float,
help="gradient clipping max norm (default: %(default)s",
)
parser.add_argument("--checkpoint", type=str, help="Path to a checkpoint")
args = parser.parse_args(argv)
return args
def encode(argv):
parser = argparse.ArgumentParser(
description="Encode image/video to bit-stream")
parser.add_argument(
"input",
type=str,
help=
"Input path, the first frame will be encoded with a NN image codec if the input is a raw yuv sequence",
)
parser.add_argument(
"-f",
"--num_of_frames",
default=-1,
type=int,
help=
"Number of frames to be coded. -1 will encode all frames of input (default: %(default)s)",
)
parser.add_argument(
"--model",
choices=models.keys(),
default=list(models.keys())[0],
help="NN model to use (default: %(default)s)",
)
parser.add_argument(
"-m",
"--metric",
choices=metric_ids.keys(),
default="mse",
help="metric trained against (default: %(default)s)",
)
parser.add_argument(
"-q",
"--quality",
choices=list(range(1, 9)),
type=int,
default=3,
help="Quality setting (default: %(default)s)",
)
parser.add_argument(
"-c",
"--coder",
choices=compressai.available_entropy_coders(),
default=compressai.available_entropy_coders()[0],
help="Entropy coder (default: %(default)s)",
)
parser.add_argument("-o", "--output", help="Output path")
parser.add_argument("--cuda", action="store_true", help="Use cuda")
args = parser.parse_args(argv)
if not args.output:
args.output = Path(Path(args.input).resolve().name).with_suffix(".bin")
device = "cuda" if args.cuda and torch.cuda.is_available() else "cpu"
_encode(
args.input,
args.num_of_frames,
args.model,
args.metric,
args.quality,
args.coder,
device,
args.output,
)
from torchvision.transforms import ToPILImage, ToTensor
import compressai
from compressai.datasets import RawVideoSequence, VideoFormat
from compressai.transforms.functional import (
rgb2ycbcr,
ycbcr2rgb,
yuv_420_to_444,
yuv_444_to_420,
)
from compressai.zoo import image_models, models
torch.backends.cudnn.deterministic = True
model_ids = {k: i for i, k in enumerate(models.keys())}
metric_ids = {"mse": 0, "ms-ssim": 1}
Frame = Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, ...]]
class CodecType(Enum):
IMAGE_CODEC = 0
VIDEO_CODEC = 1
NUM_CODEC_TYPE = 2
class CodecInfo(NamedTuple):
codec_header: Tuple
original_size: Tuple
def setup_args():
parent_parser = argparse.ArgumentParser(add_help=False, )
# Common options.
parent_parser.add_argument("dataset", type=str, help="dataset path")
parent_parser.add_argument(
"-a",
"--arch",
type=str,
choices=pretrained_models.keys(),
help="model architecture",
required=True,
)
parent_parser.add_argument(
"-c",
"--entropy-coder",
choices=compressai.available_entropy_coders(),
default=compressai.available_entropy_coders()[0],
help="entropy coder (default: %(default)s)",
)
parent_parser.add_argument(
"--entropy-estimation",
action="store_true",
help="use evaluated entropy estimation (no entropy coding)",
)
parent_parser.add_argument(
"-v",
"--verbose",
action="store_true",
help="verbose mode",
)
parser = argparse.ArgumentParser(
description="Evaluate a model on an image dataset.", add_help=True)
subparsers = parser.add_subparsers(help="model source",
dest="source",
required=True)
# Options for pretrained models
pretrained_parser = subparsers.add_parser("pretrained",
parents=[parent_parser])
pretrained_parser.add_argument(
"-m",
"--metric",
type=str,
choices=["mse", "ms-ssim"],
default="mse",
help="metric trained against (default: %(default)s)",
)
pretrained_parser.add_argument(
"-q",
"--quality",
dest="qualities",
nargs="+",
type=int,
default=(1, ),
)
checkpoint_parser = subparsers.add_parser("checkpoint",
parents=[parent_parser])
checkpoint_parser.add_argument(
"-p",
"--path",
dest="paths",
type=str,
nargs="*",
required=True,
help="checkpoint path",
)
return parser