def load_next_image(self,loss_task):
if loss_task == 0:
if self.cls_cur == len(self.cls_list):
self.cls_cur = 0
random.shuffle(self.cls_list)
cur_data = self.cls_list[self.cls_cur] # Get the image index
im = cur_data[0]
label = cur_data[1]
roi = [-1,-1,-1,-1]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
if random.choice([0,1])==1:
im = cv2.flip(im,random.choice([-1,0,1]))
self.cls_cur += 1
return im, label, roi, pts
if loss_task == 1:
if self.roi_cur == len(self.roi_list):
self.roi_cur = 0
random.shuffle(self.roi_list)
cur_data = self.roi_list[self.roi_cur] # Get the image index
im = cur_data[0]
label = -1
roi = cur_data[2]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
self.roi_cur += 1
return im, label, roi, pts
if loss_task == 2:
if self.pts_cur == len(self.pts_list):
self.pts_cur = 0
random.shuffle(self.pts_list)
cur_data = self.pts_list[self.pts_cur] # Get the image index
im = cur_data[0]
label = -1
roi = [-1,-1,-1,-1]
pts = cur_data[3]
self.pts_cur += 1
return im, label, roi, pts
################################################################################
######################Regression Loss Layer By Python###########################
################################################################################
python类Layer()的实例源码
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='PythonWindowDataParallel Layer')
parser.add_argument('--source', default='', type=str)
parser.add_argument('--root_folder', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--is_mirror', dest='is_mirror', action='store_true', default=False)
parser.add_argument('--resume_iter', default=0, type=int)
parser.add_argument('--jitter_pct', default=0, type=float)
parser.add_argument('--jitter_amt', default=0, type=int)
parser.add_argument('--ncpu', default=2, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='PythonWindowDataRots Layer')
parser.add_argument('--source', default='', type=str)
parser.add_argument('--root_folder', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--is_random_roll', dest='is_gray', action='store_true', default=True)
parser.add_argument('--no-is_random_roll', dest='is_gray', action='store_false')
parser.add_argument('--is_mirror', dest='is_mirror', action='store_true', default=False)
parser.add_argument('--resume_iter', default=0, type=int)
parser.add_argument('--jitter_pct', default=0, type=float)
parser.add_argument('--jitter_amt', default=0, type=int)
parser.add_argument('--nrmlz_file', default='None', type=str)
parser.add_argument('--ncpu', default=2, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def _parse_args(self, str_arg):
parser = argparse.ArgumentParser(description='Python Layer Parameters Pi')
parser.add_argument('--num_classes', default=None, type=int)
parser.add_argument('--num_data', default=None, type=int)
args = parser.parse_args(str_arg.split())
return args
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
top[0].data[...] = self.data
top[1].data[...] = self.label
# pick next input randomly, if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
for i, t in enumerate(self.tops):
top[i].data[...] = self.data[t]
# pick next input randomly if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
top[0].data[...] = self.data
top[1].data[...] = self.label
# pick next input randomly, if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
top[0].data[...] = self.data
top[1].data[...] = self.label
# pick next input randomly, if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
for i, t in enumerate(self.tops):
top[i].data[...] = self.data[t]
# pick next input randomly if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
top[0].data[...] = self.data
top[1].data[...] = self.label
# pick next input randomly, if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
top[0].data[...] = self.data
top[1].data[...] = self.label
# pick next input randomly, if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def forward(self, bottom, top):
# assign the output of the Python Layer as the input of the
# next layers
for i, t in enumerate(self.tops):
top[i].data[...] = self.data[t]
# pick next input randomly if in train, or sequentially if in testing
if self.random:
self.idx = random.randint(0, len(self.indices)-1)
else:
self.idx += 1
if self.idx == len(self.indices):
self.idx = 0
def view_bar(num, total):
rate = float(num) / total
rate_num = int(rate * 100)
r = '\r[%s%s]%d%%' % ("#"*rate_num, " "*(100-rate_num), rate_num, )
sys.stdout.write(r)
sys.stdout.flush()
################################################################################
#########################Data Layer By Python###################################
################################################################################
def backward(self,top,propagate_down,bottom):
for i in range(2):
if not propagate_down[i] or self.N==0:
continue
if i == 0:
sign = 1
else:
sign = -1
bottom[i].diff[...] = sign * self.diff / bottom[i].num
################################################################################
#############################Classify Layer By Python###########################
################################################################################
def view_bar(num, total):
rate = float(num) / total
rate_num = int(rate * 100)
r = '\r[%s%s]%d%%' % ("#"*rate_num, " "*(100-rate_num), rate_num, )
sys.stdout.write(r)
sys.stdout.flush()
################################################################################
#########################Data Layer By Python###################################
################################################################################
def load_next_image(self,loss_task):
if loss_task == 0:
if self.cls_cur == len(self.cls_list):
self.cls_cur = 0
random.shuffle(self.cls_list)
cur_data = self.cls_list[self.cls_cur] # Get the image index
im = cur_data[0]
label = cur_data[1]
roi = [-1,-1,-1,-1]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
if random.choice([0,1])==1:
im = cv2.flip(im,random.choice([-1,0,1]))
self.cls_cur += 1
return im, label, roi, pts
if loss_task == 1:
if self.roi_cur == len(self.roi_list):
self.roi_cur = 0
random.shuffle(self.roi_list)
cur_data = self.roi_list[self.roi_cur] # Get the image index
im = cur_data[0]
label = -1
roi = cur_data[2]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
self.roi_cur += 1
return im, label, roi, pts
if loss_task == 2:
if self.pts_cur == len(self.pts_list):
self.pts_cur = 0
random.shuffle(self.pts_list)
cur_data = self.pts_list[self.pts_cur] # Get the image index
im = cur_data[0]
label = -1
roi = [-1,-1,-1,-1]
pts = cur_data[3]
self.pts_cur += 1
return im, label, roi, pts
################################################################################
######################Regression Loss Layer By Python###########################
################################################################################
def view_bar(num, total):
rate = float(num) / total
rate_num = int(rate * 100)
r = '\r[%s%s]%d%%' % ("#"*rate_num, " "*(100-rate_num), rate_num, )
sys.stdout.write(r)
sys.stdout.flush()
################################################################################
#########################Data Layer By Python###################################
################################################################################
def load_next_image(self,loss_task):
if loss_task == 0:
if self.cls_cur == len(self.cls_list):
self.cls_cur = 0
random.shuffle(self.cls_list)
cur_data = self.cls_list[self.cls_cur] # Get the image index
im = cur_data[0]
label = cur_data[1]
roi = [-1,-1,-1,-1]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
if random.choice([0,1])==1:
im = cv2.flip(im,random.choice([-1,0,1]))
self.cls_cur += 1
return im, label, roi, pts
if loss_task == 1:
if self.roi_cur == len(self.roi_list):
self.roi_cur = 0
random.shuffle(self.roi_list)
cur_data = self.roi_list[self.roi_cur] # Get the image index
im = cur_data[0]
label = -1
roi = cur_data[2]
pts = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
self.roi_cur += 1
return im, label, roi, pts
if loss_task == 2:
if self.pts_cur == len(self.pts_list):
self.pts_cur = 0
random.shuffle(self.pts_list)
cur_data = self.pts_list[self.pts_cur] # Get the image index
im = cur_data[0]
label = -1
roi = [-1,-1,-1,-1]
pts = cur_data[3]
self.pts_cur += 1
return im, label, roi, pts
################################################################################
#########################ROI Loss Layer By Python###############################
################################################################################
def backward(self,top,propagate_down,bottom):
for i in range(2):
if not propagate_down[i] or self.N==0:
continue
if i == 0:
sign = 1
else:
sign = -1
bottom[i].diff[...] = sign * self.diff / bottom[i].num
################################################################################
#############################SendData Layer By Python###########################
################################################################################
streetview_data_group_rots.py 文件源码
项目：caffe-python-layers
作者: pulkitag
项目源码
文件源码
阅读 28
收藏 0
点赞 0
评论 0
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='PythonGroupDataRots Layer')
parser.add_argument('--im_root_folder', default='', type=str)
#The file which contains the name of groups
parser.add_argument('--grplist_file', default='', type=str)
#File containing information what kind of labels
#should be extractee etc.
parser.add_argument('--lbinfo_file', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--im_size', default=101, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--random_roll_max', default=0, type=float)
parser.add_argument('--is_mirror', dest='is_mirror', action='store_true', default=False)
parser.add_argument('--resume_iter', default=0, type=int)
parser.add_argument('--jitter_pct', default=0, type=float)
parser.add_argument('--jitter_amt', default=0, type=int)
parser.add_argument('--nrmlz_file', default='None', type=str)
parser.add_argument('--ncpu', default=2, type=int)
#For debugging - load a single group
parser.add_argument('--is_single_grp', dest='is_single_grp',
action='store_true', default=False )
parser.add_argument('--no-is_single_grp', dest='is_single_grp', action='store_false')
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python Window Data Layer')
parser.add_argument('--source', default='', type=str)
parser.add_argument('--root_folder', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--resume_iter', default=0, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='PythonWindowDataParallel Layer')
parser.add_argument('--num_threads', default=16, type=int)
parser.add_argument('--source', default='', type=str)
parser.add_argument('--root_folder', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--resume_iter', default=0, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L1 Loss Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L1 Loss With Ignore Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L2Loss With Ignore Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L2LossQuaternion With Ignore Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L2Loss With Ignore Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python L1 Weighted Loss Layer')
parser.add_argument('--loss_weight', default=1.0, type=float)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='GaussRender Layer')
parser.add_argument('--K', default=100.0, type=float)
parser.add_argument('--T', default=-50.0, type=float)
parser.add_argument('--sigma', default=0.001, type=float)
parser.add_argument('--imgSz', default=224, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
def parse_args(cls, argsStr):
parser = argparse.ArgumentParser(description='Python Window Data Layer')
parser.add_argument('--source', default='', type=str)
parser.add_argument('--root_folder', default='', type=str)
parser.add_argument('--mean_file', default='', type=str)
parser.add_argument('--batch_size', default=128, type=int)
parser.add_argument('--crop_size', default=192, type=int)
parser.add_argument('--is_gray', dest='is_gray', action='store_true')
parser.add_argument('--no-is_gray', dest='is_gray', action='store_false')
parser.add_argument('--resume_iter', default=0, type=int)
args = parser.parse_args(argsStr.split())
print('Using Config:')
pprint.pprint(args)
return args
