Python caffe 模块，Layer() 实例源码

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 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###########################
################################################################################

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