Python Logger.error方法代码示例

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def vis_peaks(self, heatmap, ori_img, name='default',
                  vis_dir=PEAK_DIR, scale_factor=1, img_size=(368, 368)):
        vis_dir = os.path.join(self.configer.get('project_dir'), vis_dir)
        if not os.path.exists(vis_dir):
            Log.error('Dir:{} not exists!'.format(vis_dir))
            os.makedirs(vis_dir)

        if not isinstance(heatmap, np.ndarray):
            if len(heatmap.size()) != 3:
                Log.error('Heatmap size is not valid.')
                exit(1)

            heatmap = heatmap.data.squeeze().cpu().numpy().transpose(1, 2, 0)

        if not isinstance(ori_img, np.ndarray):
            ori_img = DeNormalize(mean=[128.0, 128.0, 128.0],std=[256.0, 256.0, 256.0])(ori_img)
            ori_img = ori_img.data.cpu().squeeze().numpy().transpose(1, 2, 0)

        for j in range(self.configer.get('num_keypoints')):
            peaks = self.__get_peaks(heatmap[:, :, j].data.cpu().numpy())
            image_path = os.path.join(vis_dir, '{}_{}.jpg'.format(name, j))
            for peak in peaks:
                image = cv2.circle(ori_img, (peak[0], peak[1]),
                                   self.configer.get('vis', 'circle_radius'), (0,255,0), thickness=-1)
                image = self.scale_image(image, scale_factor, img_size)
                cv2.imwrite(image_path, image)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
 def seg_net(self):
     key = self.configer.get('network', 'model_name')
     if key == 'erf_net':
         return ERFNet(self.configer.get('network', 'out_channels'))
     else:
         Log.error('Model: {} not valid!'.format(key))
         exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def get_vote_loss(self, key):
        if key == 'vote_loss':
            return VoteLoss()

        else:
            Log.error('Vote loss: {} is not valid.'.format(key))
            exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def select_pose_model(self):
        key = self.configer.get('method')
        if key == 'open_pose':
            if self.configer.get('phase') == 'train':
                return OpenPose(self.configer)
            else:
                return OpenPoseTest(self.configer)

        elif key == 'conv_pose_machine':
            if self.configer.get('phase') == 'train':
                return ConvPoseMachine(self.configer)
            else:
                return ConvPoseMachineTest(self.configer)

        elif key == 'associative_embedding':
            if self.configer.get('phase') == 'train':
                return AssociativeEmbedding(self.configer)
            else:
                return AssociativeEmbeddingTest(self.configer)

        elif key == 'fashion_ai':
            if self.configer.get('phase') == 'train':
                return FashionAI(self.configer)
            else:
                return FashionAITest(self.configer)

        else:
            Log.error('Pose Model: {} is not valid.'.format(key))
            exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def select_det_model(self):
        key = self.configer.get('method')
        if key == 'pose_top_down':
            return ConvPoseMachine(self.configer)

        else:
            Log.error('Det Model: {} is not valid.'.format(key))

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def test(self):
        base_dir = os.path.join(self.configer.get('project_dir'),
                                'val/results/pose', self.configer.get('dataset'), 'test')
        if not os.path.exists(base_dir):
            os.makedirs(base_dir)

        test_img = self.configer.get('test_img')
        test_dir = self.configer.get('test_dir')
        if test_img is None and test_dir is None:
            Log.error('test_img & test_dir not exists.')
            exit(1)

        if test_img is not None and test_dir is not None:
            Log.error('Either test_img or test_dir.')
            exit(1)

        if test_img is not None:
            filename = test_img.rstrip().split('/')[-1]
            save_path = os.path.join(base_dir, filename)
            self.__test_img(test_img, save_path)

        else:
            for filename in self.__list_dir(test_dir):
                image_path = os.path.join(test_dir, filename)
                save_path = os.path.join(base_dir, filename)
                self.__test_img(image_path, save_path)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
   def _validate_building_data(self, b_dict):
      """
      Ensure a dictionary containing building information is actually valid
      for updating purposes. The main goal is to validate the presence and
      format of b_id and/or l_b_id.

      If no b_id is present but a l_b_id is valid, it is set as current b_id,
      which ensures the building does not get discarded.

      Arguments:
      - b_dict: a dictionary representing a building

      Return value: True if data is valid, False otherwise
      """
      b_id     = b_dict.get("b_id", "")
      l_b_id   = b_dict.get("l_b_id", "")

      if not Building.is_valid_bid(b_id):
         if Building.is_valid_bid(l_b_id):
            Logger.warning(
               "Invalid building id: \"{}\"".format(b_id),
               "- legacy id", l_b_id, "will be used instead."
               )
            b_dict["b_id"] = l_b_id
         else:
            Logger.error(
               "Building discarded:",
               "Invalid building id", b_id,
               "and no valid legacy id is present"
               )
            return False

      return True

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
 def __test_img(self, image_path, save_path):
     if self.configer.get('dataset') == 'cityscape':
         self.__test_cityscape_img(image_path, save_path)
     elif self.configer.get('dataset') == 'laneline':
         self.__test_laneline_img(image_path, save_path)
     else:
         Log.error('Dataset: {} is not valid.'.format(self.configer.get('dataset')))
         exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def get_relation_loss(self, key):
        if key == 'embedding_loss':
            return EmbeddingLoss(num_keypoints=self.configer.get('data', 'num_keypoints'),
                                 l_vec=self.configer.get('capsule', 'l_vec'))

        else:
            Log.error('Relation loss: {} is not valid.'.format(key))
            exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def select_seg_model(self):
        key = self.configer.get('method')
        if key == 'fcn_segmentor':
            if self.configer.get('phase') == 'train':
                return FCNSegmentor(self.configer)
            else:
                return FCNSegmentorTest(self.configer)

        else:
            Log.error('Seg Model: {} is not valid.'.format(key))

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def create_submission(self, test_dir=None):
        base_dir = os.path.join(self.configer.get('project_dir'),
                                'val/results/pose', self.configer.get('dataset'), 'submission')
        if not os.path.exists(base_dir):
            os.makedirs(base_dir)

        if self.configer.get('dataset') == 'coco':
            self.__create_coco_submission(test_dir)
        else:
            Log.error('Dataset: {} is not valid.'.format(self.configer.get('dataset')))
            exit(1)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
class TestLogger(unittest.TestCase):
   
    def setUp(self):
        self.logger = Logger().getLogger(__name__)
         
    def test_log(self):
        self.logger.debug("debug")
        self.logger.info("info")
        self.logger.warn("warn")
        self.logger.error("error")
        self.logger.critical("critical")

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
class UtLogger(unittest.TestCase):
    
    def setUp(self):
        self.logger = Logger().getLogger("test.utils.UtLogger")
        
    def testLogger(self):
        self.logger.debug("1")
        self.logger.info("2")
        self.logger.warn("3")
        self.logger.error("4")
        self.logger.critical("5")

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
    def __train(self):
        """
          Train function of every epoch during train phase.
        """
        self.seg_net.train()
        start_time = time.time()

        # data_tuple: (inputs, heatmap, maskmap, tagmap, num_objects)
        for i, data_tuple in enumerate(self.train_loader):
            self.data_time.update(time.time() - start_time)
            # Change the data type.
            if len(data_tuple) < 2:
                Log.error('Train Loader Error!')
                exit(0)

            inputs = Variable(data_tuple[0].cuda(async=True))
            targets = Variable(data_tuple[1].cuda(async=True))

            # Forward pass.
            outputs = self.seg_net(inputs)

            # Compute the loss of the train batch & backward.
            loss_pixel = self.pixel_loss(outputs, targets)
            loss = loss_pixel
            self.train_losses.update(loss.data[0], inputs.size(0))
            self.optimizer.zero_grad()
            loss.backward()
            self.optimizer.step()

            # Update the vars of the train phase.
            self.batch_time.update(time.time() - start_time)
            start_time = time.time()
            self.iters += 1

            # Print the log info & reset the states.
            if self.iters % self.configer.get('solver', 'display_iter') == 0:
                Log.info('Train Iteration: {0}\t'
                         'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t'
                         'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n'
                         'Learning rate = {2}\n'
                         'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.format(
                         self.iters, self.configer.get('solver', 'display_iter'),
                         self.lr, batch_time=self.batch_time,
                         data_time=self.data_time, loss=self.train_losses))
                self.batch_time.reset()
                self.data_time.reset()
                self.train_losses.reset()

            # Check to val the current model.
            if self.val_loader is not None and \
               self.iters % self.configer.get('solver', 'test_interval') == 0:
                self.__val()

            self.optimizer, self.lr = self.module_utilizer.update_optimizer(self.seg_net, self.iters)

# 需要导入模块: from utils.logger import Logger [as 别名]
# 或者: from utils.logger.Logger import error [as 别名]
 def get_seg_loss(self, key):
     if key == 'cross_entropy_loss':
         return CrossEntropyLoss()
     elif key == 'embedding_loss':
         return EmbeddingLoss(self.configer.get('num_classes'))
     elif key == 'iou_loss':
         return IOULoss(self.configer.get('num_classes'))
     elif key == 'focal_loss':
         return FocalLoss(self.configer.get('focal', 'y'))
     else:
         Log.error('Segmentation Loss: {} is not valid.'.format(key))
         exit(1)