TYS的博客

def val(self, data_loader, **kwargs):
    self.model.eval()
    self.mode = 'val'
    self.data_loader = data_loader
    self.call_hook('before_val_epoch')
    time.sleep(2)  # Prevent possible deadlock during epoch transition
    for i, data_batch in enumerate(self.data_loader):
        self._inner_iter = i
        self.call_hook('before_val_iter')
        self.run_iter(data_batch, train_mode=False)
        self.call_hook('after_val_iter')
  	self.call_hook('after_val_epoch')

def call_hook(self, fn_name):
    for hook in self._hooks:
        getattr(hook, fn_name)(self)

def _do_evaluate(self, runner):
    """perform evaluation and save ckpt."""
    results = self.test_fn(runner.model, self.dataloader)
    runner.log_buffer.output['eval_iter_num'] = len(self.dataloader)
    key_score = self.evaluate(runner, results)

python tools/test.py configs/resnet/resnet50_b32x8_imagenet.py work_dirs/latest.pth --out result_test/resnet.pkl --metrics precision --out-items all

# 内置模块
import time 
import os

# 第三方模块
import flask

# 本地模块
from .xxx import xxx

/mmcv/cnn/bricks/registry.py
NORM_LAYERS = Registry('norm layer')

/mmcv/cnn/bricks/norm.py
NORM_LAYERS.register_module('BN', module=nn.BatchNorm2d)
NORM_LAYERS.register_module('BN1d', module=nn.BatchNorm1d)
NORM_LAYERS.register_module('BN2d', module=nn.BatchNorm2d)

registry类实现在mmcv/runner/utils/registry.py文件中

if self.downsample is not None:
        identity = self.downsample(x)

def dropout(X,drop_prob):
    X = X.float()
    assert 0<=drop_prob<=1
    keep_prob = 1-drop_prob
    if keep_prob==0:
    	return torch.torch.zeros_like(X)
    mask = (torch.rand(X.shape)<keep_prob).float()
    return mask * X / keep_prob

class Solution:
    def gobang(self, pieces: List[List[int]]) -> str:
        black = [defaultdict(set) for _ in range(4)]
        white = [defaultdict(set) for _ in range(4)]
        # 行、列、主对角线，次对角线
        def add_pieces(x, y, c):
            p = black
            if c == 1:
                p = white
            p[0][x].add(y)
            p[1][y].add(x)
            p[2][x - y].add(y)
            p[3][x + y].add(y)
        
        def get_pos(x, y, k):
            if k == 0:
                return x, y
            elif k == 1:
                return y, x
            elif k == 2:
                return x + y, y
            else:
                return x - y, y

        
        def find_pos(p, q, space):
            pos = defaultdict(set)
            for k in range(4):
                for idx, se in p[k].items():
                    vec = sorted(list(se))
                    for i in range(len(vec) - space + 1):
                        start, end = vec[i], vec[i + space - 1]
                        if end - start > 4:
                            continue
                        # s为所有可能五连的起点
                        for s in range(end - 4, start + 1):
                            arr = [v for v in range(s, s + 5) if v not in vec[i:i + space] and v not in q[k][idx]]
                            if len(arr) == 2 and space == 3:
                                x1, y1 = get_pos(idx, arr[0], k)
                                x2, y2 = get_pos(idx, arr[1], k)
                                pos[(x1, y1)].add((x2, y2))
                                pos[(x2, y2)].add((x1, y1))
                            if len(arr) == 1 and space == 4:
                                x, y = get_pos(idx, arr[0], k)
                                pos[(x, y)].add((x, y))
            return pos

        for x, y, c in pieces:
            add_pieces(x, y, c)
        # 黑棋第一步赢，则可放入位置大于等于1
        b1_pos = find_pos(black, white, 4)
        if len(b1_pos) >= 1:
            return 'Black'
        # 白棋第二步赢，则可放入位置大于1
        w2_pos = find_pos(white, black, 4)
        if len(w2_pos) > 1:
            return 'White'
        # 白棋如果存在可赢的位置，则需要填入黑棋
        if len(w2_pos) == 1:
            for x, y in w2_pos.keys():
                add_pieces(x, y, 0)
            b3_pos = find_pos(black, white, 4)
            if len(b3_pos) > 1:
                return 'Black'
        else:
            b3_pos = find_pos(black, white, 3)
            for p, cnt in b3_pos.items():
                if len(cnt) >= 2:
                    print(p, cnt)
                    return 'Black'

        return 'None'