def set(): # parse input arguments parser = argparse.ArgumentParser() parser.add_argument("type",metavar="TYPE",help="type of network",choices=["CNN","STN","cSTN","ICSTN"]) parser.add_argument("--group",default="0",help="name for group") parser.add_argument("--model",default="test",help="name for model instance") parser.add_argument("--recurN",type=int,default=4,help="number of recurrent transformations (for IC-STN)") parser.add_argument("--lr",type=float,default=1e-2,help="learning rate for classification network") parser.add_argument("--lrST",type=float,default=1e-4,help="learning rate for geometric predictor") parser.add_argument("--batchSize",type=int,default=200,help="batch size for SGD") parser.add_argument("--maxIter",type=int,default=100000,help="maximum number of training iterations") parser.add_argument("--warpType",metavar="WARPTYPE",help="type of warp function on images",default="homography", choices=["translation","similarity","affine","homography"]) parser.add_argument("--resume",type=int,default=0,help="resume from iteration number") parser.add_argument("--gpu",type=int,default=0,help="ID of GPU device (if there are multiple)") opt = parser.parse_args() opt.warpScale = {"pert":0.25,"trans":0.25} opt.baseLR,opt.baseLRST = opt.lr,opt.lrST # --- below are automatically set --- opt.H,opt.W = 28,28 opt.visBlockSize = 12 opt.GPUdevice = "/gpu:{0}".format(opt.gpu) opt.pDim = 2 if opt.warpType == "translation" else \ 4 if opt.warpType == "similarity" else \ 6 if opt.warpType == "affine" else \ 8 if opt.warpType == "homography" else None opt.canon4pts = np.array([[-1,-1],[-1,1],[1,1],[1,-1]],dtype=np.float32) opt.Im4pts = np.array([[0,0],[0,opt.H-1],[opt.W-1,opt.H-1],[opt.W-1,0]],dtype=np.float32) opt.warpGTmtrx = warp.fit(opt.canon4pts,opt.Im4pts,"affine") if opt.type=="CNN": opt.baseLRST = 0 return opt
def __init__(self, args): self.warpScale = {"pert": 0.25, "trans": 0.25} self.warpType = args.warpType self.batchSize = args.batchSize self.baseLR, self.baseLRST = args.lr, args.lrST # --- below are automatically set --- self.H, self.W = 28, 28 self.visBlockSize = 12 self.GPUdevice = "/gpu:{0}".format(args.gpu) self.pDim = 2 if self.warpType == "translation" else \ 4 if self.warpType == "similarity" else \ 6 if self.warpType == "affine" else \ 8 if self.warpType == "homography" else None self.canon4pts = np.array([[-1, -1], [-1, 1], [1, 1], [1, -1]], dtype=np.float32) self.Im4pts = np.array([[0, 0], [0, self.H - 1], [self.W - 1, self.H - 1], [self.W - 1, 0]], dtype=np.float32) self.warpGTmtrx = warp.fit(self.canon4pts, self.Im4pts, "affine") if args.type == "CNN": self.baseLRST = 0
def set(training): # parse input arguments parser = argparse.ArgumentParser() parser.add_argument("netType", choices=["CNN", "STN", "IC-STN"], help="type of network") parser.add_argument("--group", default="0", help="name for group") parser.add_argument("--model", default="test", help="name for model instance") parser.add_argument("--size", default="36x36", help="image resolution") parser.add_argument("--sizeFull", default="50x50", help="full image resolution") parser.add_argument( "--warpType", default="homography", help="type of warp function on images", choices=["translation", "similarity", "affine", "homography"]) parser.add_argument( "--warpN", type=int, default=4, help="number of recurrent transformations (for IC-STN)") parser.add_argument("--stdC", type=float, default=0.01, help="initialization stddev (classification network)") parser.add_argument("--stdGP", type=float, default=0.001, help="initialization stddev (geometric predictor)") parser.add_argument("--pertScale", type=float, default=0.25, help="initial perturbation scale") parser.add_argument("--transScale", type=float, default=0.25, help="initial translation scale") if training: # training parser.add_argument("--batchSize", type=int, default=100, help="batch size for SGD") parser.add_argument("--lrC", type=float, default=1e-2, help="learning rate (classification network)") parser.add_argument( "--lrCdecay", type=float, default=0.1, help="learning rate decay (classification network)") parser.add_argument( "--lrCstep", type=int, default=500000, help="learning rate decay step size (classification network)") parser.add_argument("--lrGP", type=float, default=None, help="learning rate (geometric predictor)") parser.add_argument("--lrGPdecay", type=float, default=0.1, help="learning rate decay (geometric predictor)") parser.add_argument( "--lrGPstep", type=int, default=500000, help="learning rate decay step size (geometric predictor)") parser.add_argument("--fromIt", type=int, default=0, help="resume training from iteration number") parser.add_argument("--toIt", type=int, default=1000000, help="run training to iteration number") else: # evaluation parser.add_argument("--batchSize", type=int, default=1, help="batch size for evaluation") opt = parser.parse_args() if opt.lrGP is None: opt.lrGP = 0 if opt.netType=="CNN" else \ 1e-3 if opt.netType=="STN" else \ 3e-5 if opt.netType=="IC-STN" else None # --- below are automatically set --- opt.training = training opt.H, opt.W = [int(x) for x in opt.size.split("x")] opt.fullH, opt.fullW = [int(x) for x in opt.sizeFull.split("x")] opt.visBlockSize = int(np.floor(np.sqrt(opt.batchSize))) opt.warpDim = 2 if opt.warpType == "translation" else \ 4 if opt.warpType == "similarity" else \ 6 if opt.warpType == "affine" else \ 8 if opt.warpType == "homography" else None opt.labelN = 43 opt.canon4pts = np.array([[-1, -1], [-1, 1], [1, 1], [1, -1]], dtype=np.float32) opt.image4pts = np.array( [[0, 0], [0, opt.H - 1], [opt.W - 1, opt.H - 1], [opt.W - 1, 0]], dtype=np.float32) opt.bbox = [ int(opt.fullW / 2 - opt.W / 2), int(opt.fullH / 2 - opt.H / 2), int(opt.fullW / 2 + opt.W / 2), int(opt.fullH / 2 + opt.H / 2) ] opt.bbox4pts = np.array( [[opt.bbox[0], opt.bbox[1]], [opt.bbox[0], opt.bbox[3]], [opt.bbox[2], opt.bbox[3]], [opt.bbox[2], opt.bbox[1]]], dtype=np.float32) opt.refMtrx = warp.fit(Xsrc=opt.canon4pts, Xdst=opt.image4pts) opt.bboxRefMtrx = warp.fit(Xsrc=opt.canon4pts, Xdst=opt.bbox4pts) if opt.netType == "STN": opt.warpN = 1 print("({0}) {1}".format(util.toGreen("{0}".format(opt.group)), util.toGreen("{0}".format(opt.model)))) print("------------------------------------------") print("network type: {0}, recurrent warps: {1}".format( util.toYellow("{0}".format(opt.netType)), util.toYellow( "{0}".format(opt.warpN if opt.netType == "IC-STN" else "X")))) print("batch size: {0}, image size: {1}x{2}".format( util.toYellow("{0}".format(opt.batchSize)), util.toYellow("{0}".format(opt.H)), util.toYellow("{0}".format(opt.W)))) print("warpScale: (pert) {0} (trans) {1}".format( util.toYellow("{0}".format(opt.pertScale)), util.toYellow("{0}".format(opt.transScale)))) if training: print("[geometric predictor] stddev={0}, lr={1}".format( util.toYellow("{0:.0e}".format(opt.stdGP)), util.toYellow("{0:.0e}".format(opt.lrGP)))) print("[classification network] stddev={0}, lr={1}".format( util.toYellow("{0:.0e}".format(opt.stdC)), util.toYellow("{0:.0e}".format(opt.lrC)))) print("------------------------------------------") if training: print( util.toMagenta("training model ({0}) {1}...".format( opt.group, opt.model))) return opt
def set(training): # parse input arguments parser = argparse.ArgumentParser() parser.add_argument("--group", default="0", help="name for group") parser.add_argument("--name", default="test", help="name for model instance") parser.add_argument("--loadGP", default=None, help="load pretrained model (GP)") parser.add_argument("--gpu", default="0", help="ID of GPU device (if there are multiple)") parser.add_argument("--size", default="120x160", help="resolution of background image") parser.add_argument("--warpN", type=int, default=1, help="number of spatial transformations") parser.add_argument("--stdGP", type=float, default=0.01, help="initialization stddev (GP)") parser.add_argument("--stdD", type=float, default=0.01, help="initialization stddev (D)") if training: # training parser.add_argument("--loadD", default=None, help="load pretrained model (D)") parser.add_argument("--lrGP", type=float, default=1e-6, help="base learning rate (GP)") parser.add_argument("--lrGPdecay", type=float, default=1.0, help="learning rate decay (GP)") parser.add_argument("--lrGPstep", type=int, default=10000, help="learning rate decay step size (GP)") parser.add_argument("--lrD", type=float, default=1e-4, help="base learning rate (D)") parser.add_argument("--lrDdecay", type=float, default=1.0, help="learning rate decay (D)") parser.add_argument("--lrDstep", type=int, default=10000, help="learning rate decay step size (D)") parser.add_argument("--unpaired", action="store_true", help="feed unpaired samples to D") parser.add_argument("--dplambda", type=float, default=0.3, help="warp update norm penalty factor") parser.add_argument("--gradlambda", type=float, default=10.0, help="gradient penalty factor") parser.add_argument("--updateD", type=int, default=2, help="update N times (D)") parser.add_argument("--updateGP", type=int, default=1, help="update N times (GP)") parser.add_argument("--batchSize", type=int, default=20, help="batch size for SGD") parser.add_argument("--fromIt", type=int, default=0, help="resume training from iteration number") parser.add_argument("--toIt", type=int, default=40000, help="run training to iteration number") parser.add_argument("--initPert", type=float, default=0.1, help="scale of initial perturbation") parser.add_argument("--homoPert", type=float, default=0.1, help="scale of homography perturbation") else: # evaluation parser.add_argument("--batchSize", type=int, default=1, help="batch size for evaluation") parser.add_argument("--initPert", type=float, default=0.0, help="scale of initial perturbation") opt = parser.parse_args() # ------ probably won't touch these ------ opt.warpType = "homography" opt.warpDim = 8 opt.warpApprox = 20 opt.GPUdevice = "/gpu:0" # ------ below automatically set ------ opt.training = training opt.H, opt.W = [int(x) for x in opt.size.split("x")] if training: opt.visBlockSize = int(np.floor(np.sqrt(opt.batchSize))) # opt.visBlockSize = 2 opt.canon4pts = np.array([[-1, -1], [-1, 1], [1, 1], [1, -1]], dtype=np.float32) opt.image4pts = np.array( [[0, 0], [0, opt.H - 1], [opt.W - 1, opt.H - 1], [opt.W - 1, 0]], dtype=np.float32) opt.refMtrx = warp.fit(Xsrc=opt.canon4pts, Xdst=opt.image4pts) print("({0}) {1}".format(util.toGreen("{0}".format(opt.group)), util.toGreen("{0}".format(opt.name)))) print("------------------------------------------") print("GPU device: {0}, batch size: {1}, warps: {2}".format( util.toYellow("{0}".format(opt.gpu)), util.toYellow("{0}".format(opt.batchSize)), util.toYellow("{0}".format(opt.warpN)))) print("image size: {0}x{1}".format(util.toYellow("{0}".format(opt.H)), util.toYellow("{0}".format(opt.W)))) if training: print( "[GP] stddev={3}, lr={0}, decay={1}, step={2}, update={4}".format( util.toYellow("{0:.0e}".format(opt.lrGP)), util.toYellow("{0}".format(opt.lrGPdecay)), util.toYellow("{0}".format(opt.lrGPstep)), util.toYellow("{0:.0e}".format(opt.stdGP)), util.toYellow("{0}".format(opt.updateGP)))) print( "[D] stddev={3}, lr={0}, decay={1}, step={2}, update={4}".format( util.toYellow("{0:.0e}".format(opt.lrD)), util.toYellow("{0}".format(opt.lrDdecay)), util.toYellow("{0}".format(opt.lrDstep)), util.toYellow("{0:.0e}".format(opt.stdD)), util.toYellow("{0}".format(opt.updateD)))) print("------------------------------------------") if training: print( util.toMagenta("training model ({0}) {1}...".format( opt.group, opt.name))) return opt
def set(training): # parse input arguments parser = argparse.ArgumentParser() parser.add_argument("--group", default="0", help="name for group") parser.add_argument("--name", default="test", help="name for model instance") parser.add_argument("--loadGP", default=None, help="load pretrained model (GP)") parser.add_argument("--size", default="128x128", help="resolution of foreground image") parser.add_argument("--warpType", default="affine", help="type of warp function on foreground image") parser.add_argument("--warpN", type=int, default=1, help="number of spatial transformations") parser.add_argument("--stdGP", type=float, default=0.01, help="initialization stddev (GP)") parser.add_argument("--stdD", type=float, default=0.01, help="initialization stddev (D)") if training: # training parser.add_argument("--loadD", default=None, help="load pretrained model (D)") parser.add_argument("--lrGP", type=float, default=1e-5, help="base learning rate (GP)") parser.add_argument("--lrGPdecay", type=float, default=1.0, help="learning rate decay (GP)") parser.add_argument("--lrGPstep", type=int, default=20000, help="learning rate decay step size (GP)") parser.add_argument("--lrD", type=float, default=1e-5, help="base learning rate (D)") parser.add_argument("--lrDdecay", type=float, default=1.0, help="learning rate decay (D)") parser.add_argument("--lrDstep", type=int, default=20000, help="learning rate decay step size (D)") parser.add_argument("--dplambda", type=float, default=1.0, help="warp update norm penalty factor") parser.add_argument("--gradlambda", type=float, default=10.0, help="gradient penalty factor") parser.add_argument("--updateD", type=int, default=2, help="update N times (D)") parser.add_argument("--updateGP", type=int, default=1, help="update N times (GP)") parser.add_argument("--batchSize", type=int, default=20, help="batch size for SGD") parser.add_argument("--histSize", type=float, default=10, help="history size in batch") parser.add_argument("--histQsize", type=int, default=10000, help="history queue size for updating D") parser.add_argument("--fromIt", type=int, default=0, help="resume training from iteration number") parser.add_argument("--toIt", type=int, default=50000, help="run training to iteration number") parser.add_argument("--pertFG", type=float, default=0.1, help="scale of initial perturbation (bags)") parser.add_argument("--pertBG", type=float, default=0.1, help="scale of initial perturbation (face)") else: # evaluation parser.add_argument("--batchSize", type=int, default=10, help="batch size for evaluation") parser.add_argument("--pertFG", type=float, default=0.0, help="scale of initial perturbation (bags)") parser.add_argument("--pertBG", type=float, default=0.0, help="scale of initial perturbation (face)") parser.add_argument("--loadImage", default=None, help="load image to test") opt = parser.parse_args() # ------ probably won't touch these ------ ## for original network # opt.dataH,opt.dataW = 144,144 # opt.centerY,opt.centerX = 72,72 ## for our new network opt.dataH,opt.dataW = 128,128 opt.centerY,opt.centerX = 64,64 opt.warpDim = 8 if opt.warpType=="homography" else \ 6 if opt.warpType=="affine" else None opt.warpApprox = 20 opt.GPUdevice = "/gpu:0" # ------ below automatically set ------ opt.training = training opt.H,opt.W = [int(x) for x in opt.size.split("x")] if training: opt.visBlockSize = int(np.floor(np.sqrt(opt.batchSize))) opt.canon4pts = np.array([[-1,-1],[-1,1],[1,1],[1,-1]],dtype=np.float32) opt.image4pts = np.array([[0,0],[0,opt.H-1],[opt.W-1,opt.H-1],[opt.W-1,0]],dtype=np.float32) opt.refMtrx = warp.fit(Xsrc=opt.canon4pts,Xdst=opt.image4pts) opt.image4pts_b = np.array([[opt.centerX-opt.W//2,opt.centerY-opt.H//2], [opt.centerX-opt.W//2,opt.centerY+opt.H//2], [opt.centerX+opt.W//2,opt.centerY+opt.H//2], [opt.centerX+opt.W//2,opt.centerY-opt.H//2]],dtype=np.float32) opt.refMtrx_b = warp.fit(Xsrc=opt.canon4pts,Xdst=opt.image4pts_b) print("({0}) {1}".format( util.toGreen("{0}".format(opt.group)), util.toGreen("{0}".format(opt.name)))) print("------------------------------------------") print("batch size: {0}, warps: {1}".format( util.toYellow("{0}".format(opt.batchSize)), util.toYellow("{0}".format(opt.warpN)))) print("image size: {0}x{1}".format( util.toYellow("{0}".format(opt.H)), util.toYellow("{0}".format(opt.W)))) if training: print("[GP] stddev={3}, lr={0}, decay={1}, step={2}, update={4}".format( util.toYellow("{0:.0e}".format(opt.lrGP)), util.toYellow("{0}".format(opt.lrGPdecay)), util.toYellow("{0}".format(opt.lrGPstep)), util.toYellow("{0:.0e}".format(opt.stdGP)), util.toYellow("{0}".format(opt.updateGP)))) print("[D] stddev={3}, lr={0}, decay={1}, step={2}, update={4}".format( util.toYellow("{0:.0e}".format(opt.lrD)), util.toYellow("{0}".format(opt.lrDdecay)), util.toYellow("{0}".format(opt.lrDstep)), util.toYellow("{0:.0e}".format(opt.stdD)), util.toYellow("{0}".format(opt.updateD)))) print("------------------------------------------") if training: print(util.toMagenta("training model ({0}) {1}...".format(opt.group,opt.name))) return opt