def __getitem__(self, index): left = self.left[index] right = self.right[index] if not self.submission: disp_L= self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) if not self.submission: dataL = self.dploader(disp_L) dataL = np.ascontiguousarray(dataL,dtype=np.float32) #Fix psi from -4:10 to 1:15 # if self.cont: # dataL = 23.46 / dataL # dataL += 5 # #Fixing to be more similar to disparity # dataL *= 10 if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL else: w, h = left_img.size left_img = left_img.crop((w-1024, h-416, w, h)) right_img = right_img.crop((w-1024, h-416, w, h)) if not self.submission: dataL = dataL[12:-12,:] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) # left_img += torch.Tensor(noisy(left_img)) # right_img += torch.Tensor(noisy(right_img)) left_img = torch.clamp(left_img, -1, 1) right_img = torch.clamp(right_img, -1, 1) if self.submission: return left_img,right_img else: return left_img, right_img, dataL
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] assert left.split('/')[-2] == right.split( '/')[-2], "L,R is not matched {}".format(left) assert left.split('/')[-1][:-9] == right.split( '/')[-1][:-10], "L,R is not matched {},{},{},{}".format( left.split('/')[-1], right.split('/')[-1], left, index) assert left.split('/')[-1][:-9] == disp_L.split( '/')[-1][:-11], "L,disp is not matched {},{},{},{}".format( left.split('/')[-1], right.split('/')[-1], left, index) left_img = self.loader(left) right_img = self.loader(right) # dataL, scaleL = self.dploader(disp_L) dataL = self.dploader(disp_L) try: dataL = np.ascontiguousarray(dataL, dtype=np.float32) except TypeError: print(dataL) print(disp_L) w, h = left_img.size left_img = left_img.crop((0, 244, w, 244 + 592)) right_img = right_img.crop((0, 244, w, 244 + 592)) dataL = dataL[ 244:-244, :] / 100.0 * 1920 / 1248 # Ground Truth output coding if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL else: w, h = left_img.size left_img = left_img right_img = right_img processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL, left
def __getitem__(self, index): left = os.path.join(self.left_dir, '{0}.png'.format(self.frame_ids[index])) right = os.path.join(self.right_dir, '{0}.png'.format(self.frame_ids[index])) # disp_L = os.path.join(self.disp_dir, '{0}.png'.format(self.frame_ids[index])) disp_L = os.path.join(self.disp_dir, '{0}.npy'.format(self.frame_ids[index])) left_img = Image.open(left).convert('RGB') right_img = Image.open(right).convert('RGB') # dataL = Image.open(disp_L) dataL = np.load(disp_L) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(80, h - th) # only the bottom half have depth measurement left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) disp_img = Image.fromarray(dataL) disp_img = disp_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = np.asarray(disp_img) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) # visualize_disparity(dataL) return left_img, right_img, dataL, get_sparse_disp(dataL, erase_ratio=0.8) else: target_w = 1248 target_h = 352 w, h = left_img.size # this will add zero padding left_img = left_img.crop((w-target_w, h-target_h, w, h)) right_img = right_img.crop((w-target_w, h-target_h, w, h)) w1, h1 = left_img.size disp_img = Image.fromarray(dataL) disp_img = disp_img.crop((w-target_w, h-target_h, w, h)) dataL = np.asarray(disp_img) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) # sparse = get_sparse_disp(dataL, erase_ratio=0.9) #visualize_disparity(dataL) # visualize_disparity(sparse) return left_img, right_img, dataL, get_sparse_disp(dataL, erase_ratio=0.8)
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL = self.dploader(disp_L) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) #print("index %d: random x1 is %d, and random y1 is %d with weight: %d; height: %d"%(index,x1,y1,w,h)) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) #dataL = np.ascontiguousarray(dataL,dtype=np.float32)/256 dataL = np.ascontiguousarray(dataL, dtype=np.float32) #print(dataL.shape) dataL = dataL[y1:y1 + th, x1:x1 + tw] #dataL = dataL[x1:x1 + tw, y1:y1 + th] #print(dataL.shape) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL else: #print "else is also ran" pre_w = 1226 pre_h = 370 w, h = left_img.size left_img = left_img.crop((w - 1232, h - 368, w, h)) right_img = right_img.crop((w - 1232, h - 368, w, h)) w1, h1 = left_img.size #dataL = dataL.crop((w-1232, h-368, w, h)) dataL = dataL[h - pre_h:h - pre_h + h, w - pre_w:w - pre_w + w] #dataL = np.ascontiguousarray(dataL,dtype=np.float32)/256 dataL = np.ascontiguousarray(dataL, dtype=np.float32) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL = self.dploader(disp_L) if self.training: w, h = left_img.size # th, tw = 256, 512 th, tw = 368, 1232 # x1 = random.randint(0, w - tw) # y1 = random.randint(0, h - th) #org # left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) # right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) left_img = left_img.crop((w - tw, h - th, w, h)) right_img = right_img.crop((w - tw, h - th, w, h)) dataL = dataL.crop((w - tw, h - th, w, h)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) / 256 # dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = transforms.ToTensor()(left_img) right_img = transforms.ToTensor()(right_img) return left_img, right_img, dataL else: w, h = left_img.size left_img = left_img.crop((w - 1232, h - 368, w, h)) right_img = right_img.crop((w - 1232, h - 368, w, h)) w1, h1 = left_img.size dataL = dataL.crop((w - 1232, h - 368, w, h)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) / 256 processed = preprocess.get_transform(augment=False) left_img = transforms.ToTensor()(left_img) right_img = transforms.ToTensor()(right_img) return left_img, right_img, dataL
def __getitem__(self, index): left = self.left[index] normal = self.normal[index] gt = self.gts[index] left_img = self.loader(left) w, h = left_img.size input1, mask1 = self.inloader(gt) # 3channel/mask sparse, mask = self.sloader(normal) th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) data_in1 = input1[y1:y1 + th, x1:x1 + tw, :] sparse_n = sparse[y1:y1 + th, x1:x1 + tw, :] mask = mask[y1:y1 + th, x1:x1 + tw, :] mask1 = mask1[y1:y1 + th, x1:x1 + tw, :] # transform to tensor processed = preprocess.get_transform( augment=False) # convert numpy(H, W, C) to FloatTensor(C x H x W) # processed = scale_crop2() left_img = processed(left_img) sparse_n = processed(sparse_n) # print("------------:", sparse_n.shape) # (1,256,512) # print("************:", mask.shape) # (256,512,1) return left_img, sparse_n, mask, mask1, data_in1
def __getitem__(self, index): left = self.left[index] input = self.input[index] sparse = self.sparse[index] left_img = self.loader(left) index_str = self.left[index].split('/')[-4][0:10] params_t = INSTICS[index_str] params = np.ones((256, 512, 3), dtype=np.float32) params[:, :, 0] = params[:, :, 0] * params_t[0] params[:, :, 1] = params[:, :, 1] * params_t[1] params[:, :, 2] = params[:, :, 2] * params_t[2] h, w, c = left_img.shape input1 = self.inloader(input) sparse, mask = self.sloader(sparse) th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) mask = np.reshape(mask, [sparse.shape[0], sparse.shape[1], 1]).astype( np.float32) params = np.reshape(params, [256, 512, 3]).astype(np.float32) left_img = left_img[y1:y1 + th, x1:x1 + tw, :] data_in1 = input1[y1:y1 + th, x1:x1 + tw, :] sparse = sparse[y1:y1 + th, x1:x1 + tw, :] mask = mask[y1:y1 + th, x1:x1 + tw, :] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) sparse = processed(sparse) mask = processed(mask) return left_img, data_in1, sparse, mask, params
def get_loader(self, force_update=False): if force_update or self.regime.update(self.epoch, self.steps): setting = self.get_setting() self._transform = get_transform(**setting['transform']) setting['data'].setdefault('transform', self._transform) self._data = get_dataset(**setting['data']) if setting['other'].get('distributed', False): setting['loader']['sampler'] = DistributedSampler(self._data) setting['loader']['shuffle'] = None # pin-memory currently broken for distributed setting['loader']['pin_memory'] = False if setting['other'].get('duplicates', 0) > 1: setting['loader']['shuffle'] = None sampler = setting['loader'].get( 'sampler', RandomSampler(self._data)) setting['loader']['sampler'] = DuplicateBatchSampler(sampler, setting['loader']['batch_size'], duplicates=setting['other']['duplicates'], drop_last=setting['loader'].get('drop_last', False)) self._sampler = setting['loader'].get('sampler', None) self._loader = torch.utils.data.DataLoader( self._data, **setting['loader']) if setting['other'].get('duplicates', 0) > 1: self._loader.batch_sampler = self._sampler return self._loader
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L= self.disp_L[index] left_img = Image.open(left).convert('RGB') right_img = Image.open(right).convert('RGB') dataL = Image.open(disp_L) guideL = Image.open(self.guide[index]) w, h = left_img.size left_img = left_img.crop((w-1280, h-384, w, h)) right_img = right_img.crop((w-1280, h-384, w, h)) w1, h1 = left_img.size dataL = dataL.crop((w-1280, h-384, w, h)) dataL = np.ascontiguousarray(dataL,dtype=np.float32)/256 guideL = guideL.crop((w-1280, h-384, w, h)) guideL = np.ascontiguousarray(guideL,dtype=np.float32)/256 processed = preprocess.get_transform(augment=False) rawimage = preprocess.identity(256) reference = rawimage(left_img) left_img = processed(left_img) right_img = processed(right_img) return reference, left_img, right_img, guideL, dataL, h, w
def __getitem__(self, index): h5p = self.h5path[index] # h5p: /nfs-data/zhengk_data/kitti_hdf5/train/2011_09_26_drive_0009_sync_image_02_0000000002.h5 left_img, sparse_n, mask, gtdepth = self.loader(h5p) # read h5 # index_str = self.left[index].split('/')[-4][0:10] index_str = h5p.split('/')[-1][0:10] params_t = INSTICS[index_str] # print(params_t) params = np.ones((256, 512, 3), dtype=np.float32) params[:, :, 0] = params[:, :, 0] * params_t[0] params[:, :, 1] = params[:, :, 1] * params_t[1] params[:, :, 2] = params[:, :, 2] * params_t[2] params = np.reshape(params, [256, 512, 3]).astype(np.float32) # convert array into tensor processed = preprocess.get_transform( augment=False) # convert numpy(H, W, C) to FloatTensor(C x H x W) # processed = scale_crop2() left_img = processed(left_img) sparse_n = processed(sparse_n) mask = processed(mask) # print("left: ", left_img.shape) # (3,256,512) # print("------------:", sparse_n.shape) # (1,256,512) # print("************:", mask.shape) # (256,512,1) return left_img, gtdepth, sparse_n, mask, params
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL = self.dploader(disp_L) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint( 80, h - th) # only the bottom half have depth measurement left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) / 256 dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) erase_ratio = random.uniform(0.9, 1) return left_img, right_img, dataL, get_sparse_disp( dataL, erase_ratio=erase_ratio) else: w, h = left_img.size left_img = left_img.crop((w - 1248, h - 352, w, h)) right_img = right_img.crop((w - 1248, h - 352, w, h)) w1, h1 = left_img.size dataL = dataL.crop((w - 1248, h - 352, w, h)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) / 256 processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL, get_sparse_disp( dataL, erase_ratio=0.95)
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] calibpath = self.calib[index] left_img = self.loader(left) right_img = self.loader(right) calib = calib_loader(calibpath) dataL = self.dploader(disp_L) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) else: w, h = left_img.size # left_img = left_img.crop((w - 1232, h - 368, w, h)) # right_img = right_img.crop((w - 1232, h - 368, w, h)) left_img = left_img.crop((w - 1200, h - 352, w, h)) right_img = right_img.crop((w - 1200, h - 352, w, h)) w1, h1 = left_img.size # dataL1 = dataL[h - 368:h, w - 1232:w] dataL = dataL[h - 352:h, w - 1200:w] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) dataL = torch.from_numpy(dataL).float() calib = torch.tensor(calib).float() return left_img, right_img, dataL, calib
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL, scaleL = self.dploader(disp_L) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = np.ascontiguousarray(dataL, dtype=np.float32) dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL, get_sparse_disp(dataL, erase_ratio=0.8) else: w, h = left_img.size left_img = left_img.crop((w - 960, h - 544, w, h)) right_img = right_img.crop((w - 960, h - 544, w, h)) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) dataL = np.pad(dataL, ((max(544 - h, 0), 0), (max(960 - w, 0), 0)), 'constant', constant_values=0) dataL = dataL[max(dataL.shape[0] - 544, 0):dataL.shape[0], max(dataL.shape[1] - 960, 0):dataL.shape[1]] return left_img, right_img, dataL, get_sparse_disp(dataL, erase_ratio=0.8)
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L= self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) disp_img = self.loader_g(disp_L) processed = preprocess.get_transform(augment=False) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) disp_img = np.ascontiguousarray(disp_img,dtype=np.float32) disp_img = disp_img[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, disp_img else: w, h = left_img.size left_img = left_img.crop((0, 0, 1024,1024)) right_img = right_img.crop((0,0,1024,1024)) disp_img = np.ascontiguousarray(disp_img,dtype=np.float32) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) disp_img = disp_img[0:1024,0:1024] return left_img, right_img, disp_img
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] # left_img = self.loader(left) # right_img = self.loader(right) # dataL, scaleL = self.dploader(disp_L) left_img = self.loader(os.path.join(self.datapath, left)) right_img = self.loader(os.path.join(self.datapath, right)) # print(os.path.join(self.datapath,left)) # print(os.path.join(self.datapath,disp_L)) dataL, _ = self.dploader(os.path.join(self.datapath, disp_L)) #print("!!!!",left_img) dataL = np.ascontiguousarray(dataL, dtype=np.float32) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = dataL[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL else: w, h = left_img.size left_img = left_img.crop((w - 960, h - 544, w, h)) right_img = right_img.crop((w - 960, h - 544, w, h)) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL
def __getitem__(self, index): img = self.img[index] lr = self.lr[index] if self.hr is not None: hr = self.hr[index] hr_ = self.dploader(hr) img_ = self.loader(img) lr_ = self.dploader(lr) if self.training: w, h = img_.size th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) img_ = img_.crop((x1, y1, x1 + tw, y1 + th)) lr_ = np.ascontiguousarray(lr_, dtype=np.float32) lr_ = lr_[y1:y1 + th, x1:x1 + tw] hr_ = np.ascontiguousarray(hr_, dtype=np.float32) hr_ = hr_[y1:y1 + th, x1:x1 + tw] processed = preprocess.get_transform(augment=False) img_ = processed(img_) return img_, lr_, hr_ elif self.hr is not None: w, h = img_.size img_ = img_.crop((w - 960, h - 544, w, h)) processed = preprocess.get_transform(augment=False) img_ = processed(img_) return img_, lr_, hr_ else: lr_ = np.ascontiguousarray(lr_, dtype=np.float32) processed = preprocess.get_transform(augment=False) img_ = processed(img_) return img_, lr_
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L= self.disp_L[index] left_img = self.loader(left) right_img = self.loader(right) dataL, scaleL = self.dploader(disp_L) dataL = np.ascontiguousarray(dataL,dtype=np.float32) #training为TURE:说明数据为训练图片;FALSE:说明数据为测试图片(用来控制照片的大小) if self.training: w, h = left_img.size th, tw = 256, 512 x1 = random.randint(0, w - tw)#random(a,b):用于生成随机数,a<=n<=b y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th))#crop(box):返回当前图像的裁剪副本,四个参数从左开始顺时针定义坐标 right_img = right_img.crop((x1, y1, x1 + tw, y1 + th)) dataL = dataL[y1:y1 + th, x1:x1 + tw]#裁剪标签数据 processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL else: w, h = left_img.size left_img = left_img.crop((w-960, h-544, w, h)) right_img = right_img.crop((w-960, h-544, w, h)) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img, dataL
def __getitem__(self, index): up = self.up[index] down = self.down[index] disp_name = self.disp_name[index] equi_info = self.equi_infos up_img = self.loader(up) down_img = self.loader(down) disp = self.dploader(disp_name) up_img = np.concatenate([np.array(up_img), equi_info], 2) down_img = np.concatenate([np.array(down_img), equi_info], 2) if self.training: h, w = up_img.shape[0], up_img.shape[1] th, tw = 512, 256 # vertical remaining cropping x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) up_img = up_img[y1:y1 + th, x1:x1 + tw, :] down_img = down_img[y1:y1 + th, x1:x1 + tw, :] disp = np.ascontiguousarray(disp, dtype=np.float32) disp = disp[y1:y1 + th, x1:x1 + tw] # preprocessing processed = preprocess.get_transform(augment=False) up_img = processed(up_img) down_img = processed(down_img) return up_img, down_img, disp else: disp = np.ascontiguousarray(disp, dtype=np.float32) processed = preprocess.get_transform(augment=False) up_img = processed(up_img) down_img = processed(down_img) return up_img, down_img, disp
def __getitem__(self, index): h5p = self.h5path[index] left_img, sparse_n, mask, mask1, normal = self.loader(h5p) # read h5 # convert array into tensor processed = preprocess.get_transform( augment=False) # convert numpy(H, W, C) to FloatTensor(C x H x W) # processed = scale_crop2() left_img = processed(left_img) sparse_n = processed(sparse_n) # print("left: ", left_img.shape) # (3,256,512) # print("------------:", sparse_n.shape) # (1,256,512) # print("************:", mask.shape) # (256,512,1) return left_img, sparse_n, mask, mask1, normal
def get_loader(self, force_update=False): if force_update or self.regime.update(self.epoch, self.steps): setting = self.get_setting() self._transform = get_transform(**setting['transform']) setting['data'].setdefault('transform', self._transform) self._data = get_dataset(**setting['data']) if setting['other'].get('distributed', False): setting['loader']['sampler'] = DistributedSampler(self._data) setting['loader']['shuffle'] = None # pin-memory currently broken for distributed setting['loader']['pin_memory'] = False self._sampler = setting['loader'].get('sampler', None) self._loader = torch.utils.data.DataLoader(self._data, **setting['loader']) return self._loader
def __getitem__(self, index): left = self.left[index] right = self.right[index] left_img = self.loader(left) right_img = self.loader(right) left_img_flip = np.fliplr(left_img) right_img_flip = np.fliplr(right_img) if self.training: w, h = left_img.size processed = preprocess.get_transform(augment=False) left_img = processed(left_img) right_img = processed(right_img) return left_img, right_img
def __getitem__(self, index): left = self.left[index] right = self.right[index] disp_L = self.disp_L[index] left_img = self.loader( left ) # TODO: converting to grayscale may cause issues with first layer of the net. should verify. right_img = self.loader(right) dataL = self.dploader(disp_L) w, h = left_img.size dataL = ((np.ascontiguousarray(dataL, dtype=np.float32) - 2**15) / 2**8) processed = preprocess.get_transform(augment=False) left_img = processed(left_img) # make this image a tensor right_img = processed(right_img) # make this image a tensor return left_img, right_img, dataL
def __getitem__(self, index): left = self.left[index] normal = self.normal[index] gt = self.gts[index] left_img = self.loader(left) w, h = left_img.size input1, mask1 = self.inloader(gt) sparse, mask = self.sloader(normal) th, tw = 256, 512 x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) left_img = left_img.crop((x1, y1, x1 + tw, y1 + th)) data_in1 = input1[y1:y1 + th, x1:x1 + tw, :] sparse_n = sparse[y1:y1 + th, x1:x1 + tw, :] mask = mask[y1:y1 + th, x1:x1 + tw, :] mask1 = mask1[y1:y1 + th, x1:x1 + tw, :] processed = preprocess.get_transform(augment=False) # processed = scale_crop2() left_img = processed(left_img) sparse_n = processed(sparse_n) return left_img, sparse_n, mask, mask1, data_in1
def main(): global args, best_prec1, dtype best_prec1 = 0 args = parser.parse_args() dtype = torch_dtypes.get(args.dtype) torch.manual_seed(args.seed) time_stamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') if args.evaluate: args.results_dir = '/tmp' if args.save is '': args.save = time_stamp save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): os.makedirs(save_path) setup_logging(os.path.join(save_path, 'log.txt'), resume=args.resume is not '') results_path = os.path.join(save_path, 'results') results = ResultsLog(results_path, title='Training Results - %s' % args.save) logging.info("saving to %s", save_path) logging.debug("run arguments: %s", args) if 'cuda' in args.device and torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed) torch.cuda.set_device(args.device_ids[0]) cudnn.benchmark = True else: args.device_ids = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = {'input_size': args.input_size, 'dataset': args.dataset} if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] - 1 best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=True), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) regime = getattr(model, 'regime', [{ 'epoch': 0, 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay }]) # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.to(args.device, dtype) model.to(args.device, dtype) val_data = get_dataset(args.dataset, 'val', transform['eval']) val_loader = torch.utils.data.DataLoader(val_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, 0) return train_data = get_dataset(args.dataset, 'train', transform['train']) train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True, drop_last=True) optimizer = OptimRegime(model.parameters(), regime) logging.info('training regime: %s', regime) for epoch in range(args.start_epoch, args.epochs): # train for one epoch train_loss, train_prec1, train_prec5 = train(train_loader, model, criterion, epoch, optimizer) # evaluate on validation set val_loss, val_prec1, val_prec5 = validate(val_loader, model, criterion, epoch) # remember best prec@1 and save checkpoint is_best = val_prec1 > best_prec1 best_prec1 = max(val_prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'regime': regime }, is_best, path=save_path) logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec1, val_prec1=val_prec1, train_prec5=train_prec5, val_prec5=val_prec5)) results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec1, val_error1=100 - val_prec1, train_error5=100 - train_prec5, val_error5=100 - val_prec5) results.plot(x='epoch', y=['train_loss', 'val_loss'], legend=['training', 'validation'], title='Loss', ylabel='loss') results.plot(x='epoch', y=['train_error1', 'val_error1'], legend=['training', 'validation'], title='Error@1', ylabel='error %') results.plot(x='epoch', y=['train_error5', 'val_error5'], legend=['training', 'validation'], title='Error@5', ylabel='error %') results.save()
def main(): global args, best_prec1 best_prec1 = 0 args = parser.parse_args() #import pdb; pdb.set_trace() #torch.save(args.batch_size/(len(args.gpus)/2+1),'multi_gpu_batch_size') if args.evaluate: args.results_dir = 'tmp-hinge/' if not os.path.exists(args.results_dir): os.mkdir(args.results_dir) if args.save is '': args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): os.makedirs(save_path) setup_logging(os.path.join(save_path, 'log.txt')) results_file = os.path.join(save_path, 'results.%s') results = ResultsLog(results_file % 'csv', results_file % 'html') logging.info("saving to %s", save_path) logging.debug("run arguments: %s", args) if 'cuda' in args.type: args.gpus = [int(i) for i in args.gpus.split(',')] torch.cuda.set_device(args.gpus[0]) cudnn.benchmark = True else: args.gpus = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = {'input_size': args.input_size, 'dataset': args.dataset} if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] - 1 best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=True), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) regime = getattr( model, 'regime', { 0: { 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay } }) # define loss function (criterion) and optimizer # CrossEntropyLoss()=log_softmax() + NLLLoss() #criterion = getattr(model, 'criterion', nn.NLLLoss)() criterion = getattr(model, 'criterion', HingeLoss)() #criterion.type(args.type) model.type(args.type) val_data = get_dataset(args.dataset, 'val', transform['eval']) val_loader = torch.utils.data.DataLoader(val_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, 0) return train_data = get_dataset(args.dataset, 'train', transform['train']) train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) logging.info('training regime: %s', regime) #import pdb; pdb.set_trace() # 不明白为什么要加这个函数,并且项目中也未找到该函数 # search_binarized_modules(model) for epoch in range(args.start_epoch, args.epochs): optimizer = adjust_optimizer(optimizer, epoch, regime) # train for one epoch train_loss, train_prec1, train_prec5 = train(train_loader, model, criterion, epoch, optimizer) # evaluate on validation set val_loss, val_prec1, val_prec5 = validate(val_loader, model, criterion, epoch) # remember best prec@1 and save checkpoint is_best = val_prec1 > best_prec1 best_prec1 = max(val_prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'regime': regime }, is_best, path=save_path) logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec1, val_prec1=val_prec1, train_prec5=train_prec5, val_prec5=val_prec5)) results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec1, val_error1=100 - val_prec1, train_error5=100 - train_prec5, val_error5=100 - val_prec5) results.plot(x='epoch', y=['train_loss', 'val_loss'], title='Loss', ylabel='loss') results.plot(x='epoch', y=['train_error1', 'val_error1'], title='Error@1', ylabel='error %') results.plot(x='epoch', y=['train_error5', 'val_error5'], title='Error@5', ylabel='error %') results.save()
def main(): hvd.init() size = hvd.size() local_rank = hvd.local_rank() torch.manual_seed(123 + hvd.rank()) global args, best_prec1 best_prec1 = 0 args = parser.parse_args() if args.pruning_mode == 1: print("thd mode") from hvd_utils.DGCoptimizer_thd import DGCDistributedOptimizer #elif args.pruning_mode == 2: # print("chunck mode") # from hvd_utils.DGCoptimizer_chunck import DGCDistributedOptimizer #elif args.pruning_mode == 3: # print("topk mode") # from hvd_utils.DGCoptimizer import DGCDistributedOptimizer #elif args.pruning_mode == 6: # print("seperate mode") # from hvd_utils.DGCoptimizer_thd_sep import DGCDistributedOptimizer #elif args.pruning_mode == 7: # print("topk quant mode") # from hvd_utils.DGCoptimizer_quant import DGCDistributedOptimizer #elif args.pruning_mode == 8: # print("topk quant mode") # from hvd_utils.DGCoptimizer_thd_quant import DGCDistributedOptimizer elif args.pruning_mode == 10: print("hybrid mode") from hvd_utils.DGCoptimizer_hybrid import DGCDistributedOptimizer elif args.pruning_mode == 11: print("hybrid quant mode") from hvd_utils.DGCoptimizer_hybrid_quant import DGCDistributedOptimizer elif args.pruning_mode == 12: print("hybrid v2 quant mode") from hvd_utils.DGCoptimizer_hybrid_quantv2 import DGCDistributedOptimizer elif args.pruning_mode == 13: print("hybrid v2 mode") from hvd_utils.DGCoptimizer_hybridv2 import DGCDistributedOptimizer else: print("pruning_mode should be set correctly") exit(0) from hvd_utils.DGCoptimizer_commoverlap import myhvdOptimizer if args.evaluate: args.results_dir = '/tmp' if args.save is '': args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): if hvd.rank() == 0: os.makedirs(save_path) else: time.sleep(1) if hvd.rank() == 0: setup_logging(os.path.join(save_path, 'log.txt')) results_file = os.path.join(save_path, 'results.%s') results = ResultsLog(results_file % 'csv', results_file % 'html') if hvd.rank() == 0: logging.info("saving to %s", save_path) logging.debug("run arguments: %s", args) if 'cuda' in args.type: torch.cuda.manual_seed(123 + hvd.rank()) args.gpus = [int(i) for i in args.gpus.split(',')] if args.use_cluster: torch.cuda.set_device(hvd.local_rank()) else: if (hvd.local_rank() < len(args.gpus)): print("rank, ", hvd.local_rank(), " is runing on ", args.gpus[hvd.local_rank()]) torch.cuda.set_device(args.gpus[hvd.local_rank()]) else: print("rank, ", hvd.local_rank(), " is runing on ", args.gpus[0]) torch.cuda.set_device(args.gpus[0]) cudnn.benchmark = True else: args.gpus = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = { 'input_size': args.input_size, 'dataset': args.dataset, 'depth': args.resnet_depth } if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] + 1 best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=True), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) regime = getattr( model, 'regime', { 0: { 'optimizer': args.optimizer, 'lr': args.lr #'momentum': args.momentum, #'weight_decay': args.weight_decay } }) adapted_regime = {} logging.info('self-defined momentum : %f, weight_decay : %f', args.momentum, args.weight_decay) for e, v in regime.items(): if args.lr_bb_fix and 'lr' in v: # v['lr'] *= (args.batch_size / args.mini_batch_size) ** 0.5 v['lr'] *= (args.batch_size * hvd.size() / 128)**0.5 adapted_regime[e] = v regime = adapted_regime # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.type(args.type) model.type(args.type) #val_data = get_dataset(args.dataset, 'val', transform['eval']) #val_loader = torch.utils.data.DataLoader( # val_data, # batch_size=args.batch_size, shuffle=False, # num_workers=args.workers, pin_memory=True) val_loader = None if args.evaluate: validate(val_loader, model, criterion, 0) return #train_data = get_dataset(args.dataset, 'train', transform['train']) #train_loader = torch.utils.data.DataLoader( # train_data, # batch_size=args.batch_size, shuffle=True, # num_workers=args.workers, pin_memory=True) train_loader = None if hvd.rank() == 0: logging.info('training regime: %s', regime) print({ i: list(w.size()) for (i, w) in enumerate(list(model.parameters())) }) init_weights = [w.data.cpu().clone() for w in list(model.parameters())] U = [] V = [] print("current rank ", hvd.rank(), "local_rank ", hvd.local_rank(), \ " USE_PRUNING ", args.use_pruning) print("model ", args.model, " use_nesterov ", args.use_nesterov) #TODO u, v will be cleared at the begining of each epoch if args.use_pruning: optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) if args.gpus is not None: optimizer = DGCDistributedOptimizer( optimizer, named_parameters=model.named_parameters(), use_gpu=True, momentum=0.9, weight_decay=1e-4) else: optimizer = DGCDistributedOptimizer( optimizer, named_parameters=model.named_parameters(), use_gpu=False, momentum=0.9, weight_decay=1e-4) else: if args.use_hvddist: print("use orignal hvd DistributedOptimizer") optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4, nesterov=True) #optimizer = hvd.DistributedOptimizer(optimizer, named_parameters=model.named_parameters()) optimizer = myhvdOptimizer( optimizer, named_parameters=model.named_parameters()) else: optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) if args.gpus is not None: optimizer = DGCDistributedOptimizer( optimizer, named_parameters=model.named_parameters(), use_gpu=True, momentum=0.9, weight_decay=1e-4, use_allgather=False) else: optimizer = DGCDistributedOptimizer( optimizer, named_parameters=model.named_parameters(), use_gpu=False, momentum=0.9, weight_decay=1e-4, use_allgather=False) hvd.broadcast_parameters(model.state_dict(), root_rank=0) global_begin_time = time.time() for epoch in range(args.start_epoch, args.epochs // hvd.size()): #optimizer = adjust_optimizer(optimizer, epoch, regime) for e, v in regime.items(): if epoch == e // hvd.size(): for param_group in optimizer.param_groups: param_group['lr'] = v['lr'] break # train for one epoch train_result = train(train_loader, model, criterion, epoch, optimizer, U, V) sys.exit() train_loss, train_prec1, train_prec5, U, V = [ train_result[r] for r in ['loss', 'prec1', 'prec5', 'U', 'V'] ] # evaluate on validation set val_result = validate(val_loader, model, criterion, epoch) val_loss, val_prec1, val_prec5 = [ val_result[r] for r in ['loss', 'prec1', 'prec5'] ] # remember best prec@1 and save checkpoint is_best = val_prec1 > best_prec1 best_prec1 = max(val_prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'regime': regime }, is_best, path=save_path) if hvd.rank() == 0: if torch.__version__ == "0.4.0": logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss.cpu().numpy(), val_loss=val_loss.cpu().numpy(), train_prec1=train_prec1.cpu().numpy(), val_prec1=val_prec1.cpu().numpy(), train_prec5=train_prec5.cpu().numpy(), val_prec5=val_prec5.cpu().numpy())) else: logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec1, val_prec1=val_prec1, train_prec5=train_prec5, val_prec5=val_prec5)) #Enable to measure more layers idxs = [0] #,2,4,6,7,8,9,10]#[0, 12, 45, 63] step_dist_epoch = { 'step_dist_n%s' % k: (w.data.cpu() - init_weights[k]).norm() for (k, w) in enumerate(list(model.parameters())) if k in idxs } if (hvd.rank() == 0): current_time = time.time() if hvd.rank() == 0: results.add(epoch=epoch + 1, train_loss=train_loss.cpu().numpy(), val_loss=val_loss.cpu().numpy(), train_error1=100 - train_prec1.cpu().numpy(), val_error1=100 - val_prec1.cpu().numpy(), train_error5=100 - train_prec5.cpu().numpy(), val_error5=100 - val_prec5.cpu().numpy(), eslapse=current_time - global_begin_time) else: results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec1, val_error1=100 - val_prec1, train_error5=100 - train_prec5, val_error5=100 - val_prec5, eslapse=current_time - global_begin_time) #results.plot(x='epoch', y=['train_loss', 'val_loss'], # title='Loss', ylabel='loss') #results.plot(x='epoch', y=['train_error1', 'val_error1'], # title='Error@1', ylabel='error %') #results.plot(x='epoch', y=['train_error5', 'val_error5'], # title='Error@5', ylabel='error %') #for k in idxs: # results.plot(x='epoch', y=['step_dist_n%s' % k], # title='step distance per epoch %s' % k, # ylabel='val') results.save()
def main(): torch.manual_seed(123) global args, best_prec1 best_prec1 = 0 args = parser.parse_args() if args.regime_bb_fix: args.epochs *= int(ceil(args.batch_size / 256.)) if args.evaluate: args.results_dir = '/home/shai/tensorflow/generated_data/Pytorch/' if args.save is '': args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): os.makedirs(save_path) writer = SummaryWriter(save_path) setup_logging(os.path.join(save_path, 'log.txt')) results_file = os.path.join(save_path, 'results.%s') results = ResultsLog(results_file % 'csv', results_file % 'html') logging.info("saving to %s", save_path) logging.debug("run arguments: %s", args) if 'cuda' in args.type: torch.cuda.manual_seed(123) args.gpus = [int(i) for i in args.gpus.split(',')] torch.cuda.set_device(args.gpus[0]) cudnn.benchmark = True else: args.gpus = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = {'input_size': args.input_size, 'dataset': args.dataset} if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] - 1 best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=True), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) regime = getattr( model, 'regime', { 0: { 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay } }) adapted_regime = {} max_lr = args.lr * (args.batch_size / 256.) for e, v in regime.items(): if args.lr_bb_fix and 'lr' in v: v['lr'] *= (args.batch_size / 256.)**0.5 if args.regime_bb_fix: e *= ceil(args.batch_size / 256.) adapted_regime[e] = v regime = adapted_regime # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.type(args.type) model.type(args.type) val_data = get_dataset(args.dataset, 'val', transform['eval']) val_loader = torch.utils.data.DataLoader(val_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, 0) return train_data = get_dataset(args.dataset, 'train', transform['train']) train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) optimizer = SGDAdjustOptimizer(optimizer, iters_per_adjust=args.iters_per_adjust, disable_lr_change=args.disable_lr_change, writer=writer, sqrt_factor=args.sqrt_factor, max_lr=max_lr) logging.info('training regime: %s', regime) init_weights = [w.data.cpu().clone() for w in list(model.parameters())] for epoch in range(args.start_epoch, args.epochs): if args.disable_lr_change == True: tmp_base_optimizer = adjust_optimizer(optimizer.base_optimizer, epoch, regime) optimizer.set_base_optimizer(tmp_base_optimizer) # train for one epoch train_loss, train_prec1, train_prec5 = train(train_loader, model, criterion, epoch, optimizer) # evaluate on validation set val_loss, val_prec1, val_prec5 = validate(val_loader, model, criterion, epoch) # remember best prec@1 and save checkpoint is_best = val_prec1 > best_prec1 best_prec1 = max(val_prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'regime': regime }, is_best, path=save_path) logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec1, val_prec1=val_prec1, train_prec5=train_prec5, val_prec5=val_prec5)) writer.add_scalar('train_loss', train_loss, epoch) writer.add_scalar('val_loss', val_loss, epoch) writer.add_scalar('train_error1', 100 - train_prec1, epoch) writer.add_scalar('val_error1', 100 - val_prec1, epoch) writer.add_scalar('train_error5', 100 - train_prec5, epoch) writer.add_scalar('val_error5', 100 - val_prec5, epoch) #Enable to measure more layers idxs = [0] #,2,4,6,7,8,9,10]#[0, 12, 45, 63] step_dist_epoch = { 'step_dist_n%s' % k: (w.data.cpu() - init_weights[k]).norm() for (k, w) in enumerate(list(model.parameters())) if k in idxs } results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec1, val_error1=100 - val_prec1, train_error5=100 - train_prec5, val_error5=100 - val_prec5, **step_dist_epoch) results.plot(x='epoch', y=['train_loss', 'val_loss'], title='Loss', ylabel='loss') results.plot(x='epoch', y=['train_error1', 'val_error1'], title='Error@1', ylabel='error %') results.plot(x='epoch', y=['train_error5', 'val_error5'], title='Error@5', ylabel='error %') for k in idxs: results.plot(x='epoch', y=['step_dist_n%s' % k], title='step distance per epoch %s' % k, ylabel='val') results.save() writer.close()
datay = datatype[1] for smpl in np.split(np.random.permutation(range(dataX.shape[0])), 10): ops = opfun(dataX[smpl]) tgts = Variable(torch.from_numpy(datay[smpl]).long().squeeze()) var = F.nll_loss(ops, tgts).data.numpy() / 10 data_for_plotting[i, j] += accfun(ops, datay[smpl]) / 10. j += 1 print(data_for_plotting[i]) np.save('ShallowNetC3-intermediate-values', data_for_plotting) i += 1 # # Data loading code default_transform = { 'train': get_transform("cifar10", input_size=None, augment=True), 'eval': get_transform("cifar10", input_size=None, augment=False) } transform = getattr(model, 'input_transform', default_transform) # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.type(torch.FloatTensor) # #model.type(torch.cuda.FloatTensor) i = 0 for batch_size in batch_range: mydict = {} batchmodel = torch.load("./models/ShallowNetCIFAR100BatchSize" + str(batch_size) + ".pth") for key, value in batchmodel.items():
def main(): global args, best_prec global progress, task2, task3 best_prec = 0 args = parser.parse_args() if args.evaluate: args.results_dir = './tmp' if args.save is '': args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): os.makedirs(save_path) setup_logging(os.path.join(save_path, 'log.txt')) results_file = os.path.join(save_path, 'results.%s') results = ResultsLog(results_file % 'csv', results_file % 'html') logging.info("saving to %s", save_path) logging.info("run arguments: %s", args) if 'cuda' in args.type: args.gpus = [int(i) for i in args.gpus.split(',')] torch.cuda.set_device(args.gpus[0]) cudnn.benchmark = True else: args.gpus = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = {'input_size': args.input_size, 'dataset': args.dataset} if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'checkpoint.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] best_prec = checkpoint['best_prec'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=False), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) regime = getattr( model, 'regime', { 0: { 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay } }) # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.type(args.type) model.type(args.type) train_data = get_dataset(args.dataset, 'train', transform['train']) train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) logging.info('train dataset size: %d', len(train_data)) val_data = get_dataset(args.dataset, 'eval', transform['eval']) val_loader = torch.utils.data.DataLoader(val_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) logging.info('validate dataset size: %d', len(val_data)) # print net struct if args.dataset == 'mnist': summary(model, (1, 28, 28)) elif args.dataset == 'cifar10': summary(model, (3, 32, 32)) if args.evaluate: with Progress( "[progress.description]{task.description}{task.completed}/{task.total}", BarColumn(), "[progress.percentage]{task.percentage:>3.0f}%", TimeRemainingColumn(), auto_refresh=False) as progress: task3 = progress.add_task("[yellow]validating:", total=math.ceil( len(val_data) / args.batch_size)) val_loss, val_prec1 = validate(val_loader, model, criterion, 0) logging.info('Evaluate {0}\t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t'.format( args.evaluate, val_loss=val_loss, val_prec1=val_prec1)) return optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) logging.info('training regime: %s', regime) # restore results train_loss_list, train_prec_list = [], [] val_loss_list, val_prec_list = [], [] # print progressor with Progress( "[progress.description]{task.description}{task.completed}/{task.total}", BarColumn(), "[progress.percentage]{task.percentage:>3.0f}%", TimeRemainingColumn(), auto_refresh=False) as progress: task1 = progress.add_task("[red]epoch:", total=args.epochs) task2 = progress.add_task("[blue]training:", total=math.ceil( len(train_data) / args.batch_size)) task3 = progress.add_task("[yellow]validating:", total=math.ceil( len(val_data) / args.batch_size)) for i in range(args.start_epoch): progress.update(task1, advance=1, refresh=True) begin = time.time() for epoch in range(args.start_epoch, args.epochs): start = time.time() optimizer = adjust_optimizer(optimizer, epoch, regime) # train for one epoch train_loss, train_prec = train(train_loader, model, criterion, epoch, optimizer) train_loss_list.append(train_loss) train_prec_list.append(train_prec) # evaluate on validation set val_loss, val_prec = validate(val_loader, model, criterion, epoch) val_loss_list.append(val_loss) val_prec_list.append(val_prec) # remember best prec@1 and save checkpoint is_best = val_prec > best_prec best_prec = max(val_prec, best_prec) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec': best_prec, 'regime': regime }, is_best, path=save_path) logging.info(' Epoch: [{0}/{1}] Cost_Time: {2:.2f}s\n' ' Training Loss {train_loss:.4f} \t' 'Training Prec {train_prec1:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec {val_prec1:.3f} \t'.format( epoch + 1, args.epochs, time.time() - start, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec, val_prec1=val_prec)) results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec, val_error1=100 - val_prec) results.save() # update progressor progress.update(task1, advance=1, refresh=True) logging.info( '----------------------------------------------------------------\n' 'Whole Cost Time: {0:.2f}s Best Validation Prec {1:.3f}\n' '-----------------------------------------------------------------'. format(time.time() - begin, best_prec)) epochs = list(range(args.epochs)) draw2(epochs, train_loss_list, val_loss_list, train_prec_list, val_prec_list)
def main(): #torch.manual_seed(123) global args, best_prec1 best_prec1 = 0 args = parser.parse_args() args.epochs *= args.regime_bb_multi if args.regime_bb_fix: args.epochs *= (int)(ceil(args.batch_size * args.batch_multiplier / args.mini_batch_size)) if args.evaluate: args.results_dir = '/tmp' if args.save is '': args.save = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') save_path = os.path.join(args.results_dir, args.save) if not os.path.exists(save_path): os.makedirs(save_path) else: raise OSError('Directory {%s} exists. Use a new one.' % save_path) setup_logging(os.path.join(save_path, 'log.txt')) results_file = os.path.join(save_path, 'results.%s') results = ResultsLog(results_file % 'csv', results_file % 'html') logging.info("saving to %s", save_path) logging.info("run arguments: %s", args) if 'cuda' in args.type: #torch.cuda.manual_seed_all(123) args.gpus = [int(i) for i in args.gpus.split(',')] torch.cuda.set_device(args.gpus[0]) cudnn.benchmark = True else: args.gpus = None # create model logging.info("creating model %s", args.model) model = models.__dict__[args.model] model_config = { 'input_size': args.input_size, 'dataset': args.dataset, 'noise': args.relu_noise } if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) model = model(**model_config) logging.info("created model with configuration: %s", model_config) # optionally resume from a checkpoint if args.evaluate: if not os.path.isfile(args.evaluate): parser.error('invalid checkpoint: {}'.format(args.evaluate)) checkpoint = torch.load(args.evaluate) model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", args.evaluate, checkpoint['epoch']) elif args.resume: checkpoint_file = args.resume if os.path.isdir(checkpoint_file): results.load(os.path.join(checkpoint_file, 'results.csv')) checkpoint_file = os.path.join(checkpoint_file, 'model_best.pth.tar') if os.path.isfile(checkpoint_file): logging.info("loading checkpoint '%s'", args.resume) checkpoint = torch.load(checkpoint_file) args.start_epoch = checkpoint['epoch'] + 1 best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) logging.info("loaded checkpoint '%s' (epoch %s)", checkpoint_file, checkpoint['epoch']) else: logging.error("no checkpoint found at '%s'", args.resume) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # Data loading code default_transform = { 'train': get_transform(args.dataset, input_size=args.input_size, augment=args.augment), 'eval': get_transform(args.dataset, input_size=args.input_size, augment=False) } transform = getattr(model, 'input_transform', default_transform) if args.optimizer == 'Adam': assert (args.weight_decay is not None) regime = { 0: { 'optimizer': args.optimizer, 'lr': args.lr, 'weight_decay': args.weight_decay } } else: regime = getattr( model, 'regime', { 0: { 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay } }) if args.weight_decay: regime[0]['weight_decay'] = args.weight_decay adapted_regime = {} for e, v in regime.items(): if args.lr_bb_fix and 'lr' in v: if args.lr_fix_policy == 'sqrt': v['lr'] *= (args.batch_size * args.batch_multiplier / args.mini_batch_size)**0.5 elif args.lr_fix_policy == 'linear': v['lr'] *= (args.batch_size * args.batch_multiplier / args.mini_batch_size) else: raise ValueError('Unknown --lr_fix_policy') e *= args.regime_bb_multi if args.regime_bb_fix: e *= ceil(args.batch_size * args.batch_multiplier / args.mini_batch_size) adapted_regime[e] = v regime = adapted_regime # define loss function (criterion) and optimizer criterion = getattr(model, 'criterion', nn.CrossEntropyLoss)() criterion.type(args.type) model.type(args.type) val_data = get_dataset(args.dataset, 'val', transform['eval']) val_loader = torch.utils.data.DataLoader(val_data, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, 0) return train_data = get_dataset(args.dataset, 'train', transform['train']) train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) logging.info('training regime: %s', regime) print( {i: list(w.size()) for (i, w) in enumerate(list(model.parameters()))}) init_weights = [w.data.cpu().clone() for w in list(model.parameters())] for epoch in range(args.start_epoch, args.epochs): optimizer = adjust_optimizer(optimizer, epoch, regime) # train for one epoch train_result = train(train_loader, model, criterion, epoch, optimizer) train_loss, train_prec1, train_prec5 = [ train_result[r] for r in ['loss', 'prec1', 'prec5'] ] # evaluate on validation set val_result = validate(val_loader, model, criterion, epoch) val_loss, val_prec1, val_prec5 = [ val_result[r] for r in ['loss', 'prec1', 'prec5'] ] # remember best prec@1 and save checkpoint is_best = val_prec1 > best_prec1 best_prec1 = max(val_prec1, best_prec1) if is_best: logging.info('\n Epoch: {0}\t' 'Best Val Prec@1 {val_prec1:.3f} ' 'with Val Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, val_prec1=val_prec1, val_prec5=val_prec5)) save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'regime': regime }, is_best, path=save_path, save_all=args.save_all) logging.info('\n Epoch: {0}\t' 'Training Loss {train_loss:.4f} \t' 'Training Prec@1 {train_prec1:.3f} \t' 'Training Prec@5 {train_prec5:.3f} \t' 'Validation Loss {val_loss:.4f} \t' 'Validation Prec@1 {val_prec1:.3f} \t' 'Validation Prec@5 {val_prec5:.3f} \n'.format( epoch + 1, train_loss=train_loss, val_loss=val_loss, train_prec1=train_prec1, val_prec1=val_prec1, train_prec5=train_prec5, val_prec5=val_prec5)) #Enable to measure more layers idxs = [0] #,2,4,6,7,8,9,10]#[0, 12, 45, 63] step_dist_epoch = { 'step_dist_n%s' % k: (w.data.cpu() - init_weights[k]).norm() for (k, w) in enumerate(list(model.parameters())) if k in idxs } results.add(epoch=epoch + 1, train_loss=train_loss, val_loss=val_loss, train_error1=100 - train_prec1, val_error1=100 - val_prec1, train_error5=100 - train_prec5, val_error5=100 - val_prec5, **step_dist_epoch) results.plot(x='epoch', y=['train_loss', 'val_loss'], title='Loss', ylabel='loss') results.plot(x='epoch', y=['train_error1', 'val_error1'], title='Error@1', ylabel='error %') results.plot(x='epoch', y=['train_error5', 'val_error5'], title='Error@5', ylabel='error %') for k in idxs: results.plot(x='epoch', y=['step_dist_n%s' % k], title='step distance per epoch %s' % k, ylabel='val') results.save()